code: 
  
  
  
  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	)
  
  
  
  
  
  
  
style_context: 
  
  
  
  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()
  
  
  
  
  
  
  