



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      UpperCAmelCase_						:

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A=13   ,							_A=7   ,							_A=True   ,							_A=True   ,							_A=True   ,							_A=True   ,							_A=99   ,							_A=16   ,							_A=32   ,							_A=2   ,							_A=4   ,							_A=37   ,							_A="gelu"   ,							_A=0.1   ,							_A=0.1   ,							_A=512   ,							_A=16   ,							_A=2   ,							_A=0.0_2   ,							_A=3   ,							_A=4   ,							_A=None   ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      parent
													__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.0_2
													__SCREAMING_SNAKE_CASE								=      3
													__SCREAMING_SNAKE_CASE								=      4
													__SCREAMING_SNAKE_CASE								=      None






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ids_tensor([self.batch_size, self.seq_length]   ,							self.vocab_size	)

													__SCREAMING_SNAKE_CASE								=      None
													if self.use_input_mask:
																				__SCREAMING_SNAKE_CASE								=      random_attention_mask([self.batch_size, self.seq_length]	)

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

													__SCREAMING_SNAKE_CASE								=      None
													__SCREAMING_SNAKE_CASE								=      None
													__SCREAMING_SNAKE_CASE								=      None
													if self.use_labels:
																				__SCREAMING_SNAKE_CASE								=      ids_tensor([self.batch_size]   ,							self.type_sequence_label_size	)
																				__SCREAMING_SNAKE_CASE								=      ids_tensor([self.batch_size, self.seq_length]   ,							self.num_labels	)
																				__SCREAMING_SNAKE_CASE								=      ids_tensor([self.batch_size]   ,							self.num_choices	)

													__SCREAMING_SNAKE_CASE								=      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  _A			(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      TFAlbertModel(config=_A	)
													# inputs = {'input_ids': input_ids,
													#           'attention_mask': input_mask,
													#           'token_type_ids': token_type_ids}
													# sequence_output, pooled_output = model(**inputs)
													__SCREAMING_SNAKE_CASE								=      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
													__SCREAMING_SNAKE_CASE								=      model(_A	)

													__SCREAMING_SNAKE_CASE								=      [input_ids, input_mask]
													__SCREAMING_SNAKE_CASE								=      model(_A	)

													__SCREAMING_SNAKE_CASE								=      model(_A	)

													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  _A			(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.num_labels
													__SCREAMING_SNAKE_CASE								=      TFAlbertForPreTraining(config=_A	)
													__SCREAMING_SNAKE_CASE								=      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
													__SCREAMING_SNAKE_CASE								=      model(_A	)
													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  _A			(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      TFAlbertForMaskedLM(config=_A	)
													__SCREAMING_SNAKE_CASE								=      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
													__SCREAMING_SNAKE_CASE								=      model(_A	)
													self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.seq_length, self.vocab_size)	)






						def  _A			(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.num_labels
													__SCREAMING_SNAKE_CASE								=      TFAlbertForSequenceClassification(config=_A	)
													__SCREAMING_SNAKE_CASE								=      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
													__SCREAMING_SNAKE_CASE								=      model(_A	)
													self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.num_labels)	)






						def  _A			(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      TFAlbertForQuestionAnswering(config=_A	)
													__SCREAMING_SNAKE_CASE								=      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
													__SCREAMING_SNAKE_CASE								=      model(_A	)
													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  _A			(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.num_choices
													__SCREAMING_SNAKE_CASE								=      TFAlbertForMultipleChoice(config=_A	)
													__SCREAMING_SNAKE_CASE								=      tf.tile(tf.expand_dims(_A   ,							1	)   ,							(1, self.num_choices, 1)	)
													__SCREAMING_SNAKE_CASE								=      tf.tile(tf.expand_dims(_A   ,							1	)   ,							(1, self.num_choices, 1)	)
													__SCREAMING_SNAKE_CASE								=      tf.tile(tf.expand_dims(_A   ,							1	)   ,							(1, self.num_choices, 1)	)
													__SCREAMING_SNAKE_CASE								=      {
													    'input_ids': multiple_choice_inputs_ids,
													    'attention_mask': multiple_choice_input_mask,
													    'token_type_ids': multiple_choice_token_type_ids,
													}
													__SCREAMING_SNAKE_CASE								=      model(_A	)
													self.parent.assertListEqual(list(result['logits'].shape	)   ,							[self.batch_size, self.num_choices]	)






						def  _A			(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.num_labels
													__SCREAMING_SNAKE_CASE								=      TFAlbertForTokenClassification(config=_A	)
													__SCREAMING_SNAKE_CASE								=      {
													    'input_ids': input_ids,
													    'attention_mask': input_mask,
													    'token_type_ids': token_type_ids,
													}
													__SCREAMING_SNAKE_CASE								=      model(_A	)
													self.parent.assertListEqual(list(result['logits'].shape	)   ,							[self.batch_size, self.seq_length, self.num_labels]	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      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
													)							, 
													)								=      config_and_inputs
													__SCREAMING_SNAKE_CASE								=      {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
													return config, inputs_dict







@require_tf
class      UpperCAmelCase_						(     UpperCamelCase_					,					UpperCamelCase_					,					unittest.TestCase ):

						'''simple docstring'''




						UpperCamelCase__    :				Optional[Any]       						=						(
						    (
						        TFAlbertModel,
						        TFAlbertForPreTraining,
						        TFAlbertForMaskedLM,
						        TFAlbertForSequenceClassification,
						        TFAlbertForQuestionAnswering,
						        TFAlbertForTokenClassification,
						        TFAlbertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						UpperCamelCase__    :				str       						=						(
						    {
						        '''feature-extraction''': TFAlbertModel,
						        '''fill-mask''': TFAlbertForMaskedLM,
						        '''question-answering''': TFAlbertForQuestionAnswering,
						        '''text-classification''': TFAlbertForSequenceClassification,
						        '''token-classification''': TFAlbertForTokenClassification,
						        '''zero-shot''': TFAlbertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						UpperCamelCase__    :				Union[str, Any]       						=						False
						UpperCamelCase__    :				Any       						=						False






						def  _A			(					self   ,							_A   ,							_A   ,							_A=False	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      super()._prepare_for_class(_A   ,							_A   ,							return_labels=_A	)

													if return_labels:
																				if model_class in get_values(_A	):
																											__SCREAMING_SNAKE_CASE								=      tf.zeros(self.model_tester.batch_size   ,							dtype=tf.intaa	)

													return inputs_dict






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      TFAlbertModelTester(self	)
													__SCREAMING_SNAKE_CASE								=      ConfigTester(self   ,							config_class=_A   ,							hidden_size=37	)






						def  _A			(					self	):







													'''simple docstring'''

													self.config_tester.run_common_tests()






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_albert_model(*_A	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_albert_for_pretraining(*_A	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_albert_for_masked_lm(*_A	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_albert_for_multiple_choice(*_A	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_albert_for_sequence_classification(*_A	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_albert_for_question_answering(*_A	)






						@slow
						def  _A			(					self	):







													'''simple docstring'''

													for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__SCREAMING_SNAKE_CASE								=      TFAlbertModel.from_pretrained(_A	)
																				self.assertIsNotNone(_A	)







@require_tf
class      UpperCAmelCase_						(     unittest.TestCase ):

						'''simple docstring'''




						@slow
						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      TFAlbertForPreTraining.from_pretrained('albert-base-v2'	)
													__SCREAMING_SNAKE_CASE								=      tf.constant([[0, 1, 2, 3, 4, 5]]	)
													__SCREAMING_SNAKE_CASE								=      model(_A	)[0]

													__SCREAMING_SNAKE_CASE								=      [1, 6, 30_000]
													self.assertEqual(output.shape   ,							_A	)

													__SCREAMING_SNAKE_CASE								=      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]   ,							_A   ,							atol=1e-4	)











import unittest

from cer import CER


lowerCAmelCase__	:  Dict 		=CER()

class      UpperCAmelCase_						(     unittest.TestCase ):

						'''simple docstring'''




						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['White House']
													__SCREAMING_SNAKE_CASE								=      ['white house']
													# S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_8_1_8_1_8_1_8_1_8	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['were wolf']
													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													# S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_1_1_1_1_1_1	) < 1e-6	)

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['weae     wolf']
													# S = 1, D = 1, I = 0, N = 8, CER = 0.25
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.2_5	) < 1e-6	)

													# consecutive whitespaces case 1
													__SCREAMING_SNAKE_CASE								=      ['were wolf']
													__SCREAMING_SNAKE_CASE								=      ['were               wolf']
													# S = 0, D = 0, I = 0, N = 9, CER = 0
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.0	) < 1e-6	)

													# consecutive whitespaces case 2
													__SCREAMING_SNAKE_CASE								=      ['were   wolf']
													__SCREAMING_SNAKE_CASE								=      ['were               wolf']
													# S = 0, D = 0, I = 0, N = 9, CER = 0
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.0	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['weaewolf']
													# S = 1, D = 0, I = 0, N = 8, CER = 0.125
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_2_5	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['wereawolf']
													# S = 0, D = 1, I = 0, N = 8, CER = 0.125
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_2_5	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      ['wereolf']
													# S = 0, D = 0, I = 1, N = 8, CER = 0.125
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.1_2_5	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf']
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertEqual(_A   ,							0.0	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['werewolf', 'I am your father']
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertEqual(_A   ,							0.0	)

													__SCREAMING_SNAKE_CASE								=      ['werewolf', 'I am your father', 'doge']
													__SCREAMING_SNAKE_CASE								=      ['werxwolf', 'I       am your father', 'doge']
													# S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.0_3_5_7_1_4_2_8	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['My hovercraft', 'is full of eels']
													__SCREAMING_SNAKE_CASE								=      ['My hovercraft is full', ' of eels']
													# S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
													# whitespace at the front of " of eels" will be strip during preporcessing
													# so need to insert 2 whitespaces
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A   ,							concatenate_texts=_A	)
													self.assertTrue(abs(char_error_rate - 0.0_7_1_4_2_8	) < 1e-6	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['我能吞下玻璃而不伤身体']
													__SCREAMING_SNAKE_CASE								=      [' 能吞虾玻璃而 不霜身体啦']
													# S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.4_5_4_5_4_5_4_5_4_5	) < 1e-6	)

													__SCREAMING_SNAKE_CASE								=      ['我能吞下玻璃', '而不伤身体']
													__SCREAMING_SNAKE_CASE								=      ['我    能 吞 下 玻 璃', '而不伤身体']
													# S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertTrue(abs(char_error_rate - 0.4_5_4_5_4_5_4_5_4_5_4_5	) < 1e-6	)

													__SCREAMING_SNAKE_CASE								=      ['我能吞下玻璃而不伤身体']
													__SCREAMING_SNAKE_CASE								=      cer.compute(predictions=_A   ,							references=_A	)
													self.assertFalse(_A   ,							0.0	)






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      ['']
													__SCREAMING_SNAKE_CASE								=      ['Hypothesis']
													with self.assertRaises(_A	):
																				cer.compute(predictions=_A   ,							references=_A	)


if __name__ == "__main__":
			unittest.main()






