



import unittest

from cer import CER


UpperCamelCase__			=    CER()
class       _lowerCAmelCase (			unittest.TestCase      ):






			"""simple docstring"""





			def 		snake_case__      (					self						:							Optional[int] )    ->       str:
									"""simple docstring"""







									__lowercase											=					["""White House"""]
									__lowercase											=					["""white house"""]
									# S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.18_1818_1818 ) < 1E-6 )





			def 		snake_case__      (					self						:							Any )    ->       Any:
									"""simple docstring"""







									__lowercase											=					["""were wolf"""]
									__lowercase											=					["""werewolf"""]
									# S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.111_1111 ) < 1E-6 )

									__lowercase											=					["""werewolf"""]
									__lowercase											=					["""weae     wolf"""]
									# S = 1, D = 1, I = 0, N = 8, CER = 0.25
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.25 ) < 1E-6 )

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

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





			def 		snake_case__      (					self						:							Union[str, Any] )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					["""werewolf"""]
									__lowercase											=					["""weaewolf"""]
									# S = 1, D = 0, I = 0, N = 8, CER = 0.125
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.125 ) < 1E-6 )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					["""werewolf"""]
									__lowercase											=					["""wereawolf"""]
									# S = 0, D = 1, I = 0, N = 8, CER = 0.125
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.125 ) < 1E-6 )





			def 		snake_case__      (					self						:							Optional[int] )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					["""werewolf"""]
									__lowercase											=					["""wereolf"""]
									# S = 0, D = 0, I = 1, N = 8, CER = 0.125
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.125 ) < 1E-6 )





			def 		snake_case__      (					self						:							Any )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					["""werewolf"""]
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertEqual(lowercase      ,  0.0 )





			def 		snake_case__      (					self						:							Tuple )    ->       Any:
									"""simple docstring"""







									__lowercase											=					["""werewolf""", """I am your father"""]
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertEqual(lowercase      ,  0.0 )

									__lowercase											=					["""werewolf""", """I am your father""", """doge"""]
									__lowercase											=					["""werxwolf""", """I       am your father""", """doge"""]
									# S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.0357_1428 ) < 1E-6 )





			def 		snake_case__      (					self						:							str )    ->       Optional[int]:
									"""simple docstring"""







									__lowercase											=					["""My hovercraft""", """is full of eels"""]
									__lowercase											=					["""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
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase      ,  concatenate_texts=lowercase )
									self.assertTrue(abs(char_error_rate - 0.07_1428 ) < 1E-6 )





			def 		snake_case__      (					self						:							List[str] )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					["""我能吞下玻璃而不伤身体"""]
									__lowercase											=					[""" 能吞虾玻璃而 不霜身体啦"""]
									# S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.45_4545_4545 ) < 1E-6 )

									__lowercase											=					["""我能吞下玻璃""", """而不伤身体"""]
									__lowercase											=					["""我    能 吞 下 玻 璃""", """而不伤身体"""]
									# S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
									__lowercase											=					cer.compute(predictions=lowercase      ,  references=lowercase )
									self.assertTrue(abs(char_error_rate - 0.4545_4545_4545 ) < 1E-6 )

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







			def 		snake_case__      (					self						:							Union[str, Any] )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					[""""""]
									__lowercase											=					["""Hypothesis"""]
									with self.assertRaises(lowercase ):
															cer.compute(predictions=lowercase      ,  references=lowercase )


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










from __future__ import annotations

import unittest

from transformers import is_tf_available
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_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
			    TFXLMForMultipleChoice,
			    TFXLMForQuestionAnsweringSimple,
			    TFXLMForSequenceClassification,
			    TFXLMForTokenClassification,
			    TFXLMModel,
			    TFXLMWithLMHeadModel,
			    XLMConfig,
			)
class       _lowerCAmelCase :






			"""simple docstring"""





			def __init__(					self						:							Tuple      ,  lowercase						:							str      ,  )    ->       str:
									"""simple docstring"""







									__lowercase											=					parent
									__lowercase											=					13
									__lowercase											=					7
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					False
									__lowercase											=					False
									__lowercase											=					False
									__lowercase											=					2
									__lowercase											=					99
									__lowercase											=					0
									__lowercase											=					32
									__lowercase											=					2
									__lowercase											=					4
									__lowercase											=					0.1
									__lowercase											=					0.1
									__lowercase											=					512
									__lowercase											=					16
									__lowercase											=					2
									__lowercase											=					0.02
									__lowercase											=					3
									__lowercase											=					4
									__lowercase											=					"""last"""
									__lowercase											=					True
									__lowercase											=					None
									__lowercase											=					0





			def 		snake_case__      (					self						:							Dict )    ->       Tuple:
									"""simple docstring"""







									__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size )
									__lowercase											=					random_attention_mask([self.batch_size, self.seq_length]      ,  dtype=tf.floataa )

									__lowercase											=					None
									if self.use_input_lengths:
															__lowercase											=					(
															    ids_tensor([self.batch_size]      ,  vocab_size=2 ) + self.seq_length - 2
															)  # small variation of seq_length

									__lowercase											=					None
									if self.use_token_type_ids:
															__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.n_langs )

									__lowercase											=					None
									__lowercase											=					None
									__lowercase											=					None
									if self.use_labels:
															__lowercase											=					ids_tensor([self.batch_size]      ,  self.type_sequence_label_size )
															__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.num_labels )
															__lowercase											=					ids_tensor([self.batch_size]      ,  2      ,  dtype=tf.floataa )
															__lowercase											=					ids_tensor([self.batch_size]      ,  self.num_choices )

									__lowercase											=					XLMConfig(
									    vocab_size=self.vocab_size      ,  n_special=self.n_special      ,  emb_dim=self.hidden_size      ,  n_layers=self.num_hidden_layers      ,  n_heads=self.num_attention_heads      ,  dropout=self.hidden_dropout_prob      ,  attention_dropout=self.attention_probs_dropout_prob      ,  gelu_activation=self.gelu_activation      ,  sinusoidal_embeddings=self.sinusoidal_embeddings      ,  asm=self.asm      ,  causal=self.causal      ,  n_langs=self.n_langs      ,  max_position_embeddings=self.max_position_embeddings      ,  initializer_range=self.initializer_range      ,  summary_type=self.summary_type      ,  use_proj=self.use_proj      ,  bos_token_id=self.bos_token_id      ,  )

									return (
									    config,
									    input_ids,
									    token_type_ids,
									    input_lengths,
									    sequence_labels,
									    token_labels,
									    is_impossible_labels,
									    choice_labels,
									    input_mask,
									)





			def 		snake_case__      (					self						:							List[str]      ,  lowercase						:							Tuple      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							int      ,  lowercase						:							List[str]      ,  )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					TFXLMModel(config=lowercase )
									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
									__lowercase											=					model(lowercase )

									__lowercase											=					[input_ids, input_mask]
									__lowercase											=					model(lowercase )
									self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size) )





			def 		snake_case__      (					self						:							Dict      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Dict      ,  lowercase						:							Dict      ,  lowercase						:							int      ,  lowercase						:							Union[str, Any]      ,  )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMWithLMHeadModel(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
									__lowercase											=					model(lowercase )

									__lowercase											=					outputs

									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size) )





			def 		snake_case__      (					self						:							Optional[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Any      ,  lowercase						:							int      ,  lowercase						:							List[Any]      ,  lowercase						:							Any      ,  lowercase						:							int      ,  lowercase						:							List[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[Any]      ,  )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					TFXLMForQuestionAnsweringSimple(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths}

									__lowercase											=					model(lowercase )

									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						:							Optional[int]      ,  lowercase						:							Tuple      ,  lowercase						:							List[str]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Any      ,  lowercase						:							Tuple      ,  lowercase						:							Any      ,  lowercase						:							Dict      ,  )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMForSequenceClassification(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths}

									__lowercase											=					model(lowercase )

									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.type_sequence_label_size) )





			def 		snake_case__      (					self						:							Union[str, Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[int]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Tuple      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Tuple      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[Any]      ,  )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.num_labels
									__lowercase											=					TFXLMForTokenClassification(config=lowercase )
									__lowercase											=					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
									__lowercase											=					model(lowercase )
									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.num_labels) )





			def 		snake_case__      (					self						:							int      ,  lowercase						:							Tuple      ,  lowercase						:							Optional[Any]      ,  lowercase						:							str      ,  lowercase						:							str      ,  lowercase						:							Dict      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							List[str]      ,  )    ->       List[str]:
									"""simple docstring"""







									__lowercase											=					self.num_choices
									__lowercase											=					TFXLMForMultipleChoice(config=lowercase )
									__lowercase											=					tf.tile(tf.expand_dims(lowercase      ,  1 )      ,  (1, self.num_choices, 1) )
									__lowercase											=					tf.tile(tf.expand_dims(lowercase      ,  1 )      ,  (1, self.num_choices, 1) )
									__lowercase											=					tf.tile(tf.expand_dims(lowercase      ,  1 )      ,  (1, self.num_choices, 1) )
									__lowercase											=					{
									    """input_ids""": multiple_choice_inputs_ids,
									    """attention_mask""": multiple_choice_input_mask,
									    """token_type_ids""": multiple_choice_token_type_ids,
									}
									__lowercase											=					model(lowercase )
									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_choices) )







			def 		snake_case__      (					self						:							str )    ->       Optional[int]:
									"""simple docstring"""







									__lowercase											=					self.prepare_config_and_inputs()
									(
									    (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      
									)											=					config_and_inputs
									__lowercase											=					{
									    """input_ids""": input_ids,
									    """token_type_ids""": token_type_ids,
									    """langs""": token_type_ids,
									    """lengths""": input_lengths,
									}
									return config, inputs_dict





@require_tf
class       _lowerCAmelCase (			_UpperCAmelCase     ,       _UpperCAmelCase     ,       unittest.TestCase      ):






			"""simple docstring"""





			lowercase__   :	Tuple  			=      (
			    (
			        TFXLMModel,
			        TFXLMWithLMHeadModel,
			        TFXLMForSequenceClassification,
			        TFXLMForQuestionAnsweringSimple,
			        TFXLMForTokenClassification,
			        TFXLMForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			lowercase__   :	List[str]  			=      (
			    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
			)  # TODO (PVP): Check other models whether language generation is also applicable
			lowercase__   :	Tuple  			=      (
			    {
			        """feature-extraction""": TFXLMModel,
			        """fill-mask""": TFXLMWithLMHeadModel,
			        """question-answering""": TFXLMForQuestionAnsweringSimple,
			        """text-classification""": TFXLMForSequenceClassification,
			        """text-generation""": TFXLMWithLMHeadModel,
			        """token-classification""": TFXLMForTokenClassification,
			        """zero-shot""": TFXLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowercase__   :	int  			=      False
			lowercase__   :	int  			=      False





			def 		snake_case__      (					self						:							Optional[int]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							List[str]      ,  lowercase						:							Dict )    ->       str:
									"""simple docstring"""







									if (
									    pipeline_test_casse_name == "QAPipelineTests"
									    and tokenizer_name is not None
									    and not tokenizer_name.endswith("""Fast""" )
									):
															# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
															# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
															# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
															return True

									return False





			def 		snake_case__      (					self						:							Tuple )    ->       List[str]:
									"""simple docstring"""







									__lowercase											=					TFXLMModelTester(self )
									__lowercase											=					ConfigTester(self      ,  config_class=lowercase      ,  emb_dim=37 )





			def 		snake_case__      (					self						:							List[str] )    ->       List[str]:
									"""simple docstring"""







									self.config_tester.run_common_tests()





			def 		snake_case__      (					self						:							List[Any] )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_model(*lowercase )





			def 		snake_case__      (					self						:							str )    ->       str:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_lm_head(*lowercase )





			def 		snake_case__      (					self						:							Optional[int] )    ->       Optional[int]:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_qa(*lowercase )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       str:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_sequence_classif(*lowercase )





			def 		snake_case__      (					self						:							Union[str, Any] )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_for_token_classification(*lowercase )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       Tuple:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_for_multiple_choice(*lowercase )







			@slow
			def 		snake_case__      (					self						:							Optional[int] )    ->       Optional[int]:
									"""simple docstring"""







									for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															__lowercase											=					TFXLMModel.from_pretrained(lowercase )
															self.assertIsNotNone(lowercase )





@require_tf
class       _lowerCAmelCase (			unittest.TestCase      ):






			"""simple docstring"""





			@slow
			def 		snake_case__      (					self						:							int )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048""" )
									__lowercase											=					tf.convert_to_tensor([[14, 447]]      ,  dtype=tf.intaa )  # the president
									__lowercase											=					[
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									]  # the president the president the president the president the president the president the president the president the president the president
									# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
									__lowercase											=					model.generate(lowercase      ,  do_sample=lowercase )
									self.assertListEqual(output_ids[0].numpy().tolist()      ,  lowercase )





