

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     snake_case__  :
				def __init__(  self     ,      _UpperCAmelCase     ,      ):




										"""simple docstring"""




										__magic_name__				:							List[Any]				=      parent
										__magic_name__				:							Dict				=      13
										__magic_name__				:							Any				=      7
										__magic_name__				:							List[str]				=      True
										__magic_name__				:							Union[str, Any]				=      True
										__magic_name__				:							Tuple				=      True
										__magic_name__				:							Tuple				=      True
										__magic_name__				:							List[Any]				=      True
										__magic_name__				:							int				=      False
										__magic_name__				:							List[str]				=      False
										__magic_name__				:							Union[str, Any]				=      False
										__magic_name__				:							Tuple				=      2
										__magic_name__				:							Union[str, Any]				=      99
										__magic_name__				:							Union[str, Any]				=      0
										__magic_name__				:							Tuple				=      32
										__magic_name__				:							Dict				=      2
										__magic_name__				:							List[str]				=      4
										__magic_name__				:							Optional[int]				=      0.1
										__magic_name__				:							Optional[int]				=      0.1
										__magic_name__				:							Union[str, Any]				=      512
										__magic_name__				:							Tuple				=      16
										__magic_name__				:							int				=      2
										__magic_name__				:							List[str]				=      0.02
										__magic_name__				:							Optional[int]				=      3
										__magic_name__				:							List[str]				=      4
										__magic_name__				:							Dict				=      'last'
										__magic_name__				:							List[str]				=      True
										__magic_name__				:							int				=      None
										__magic_name__				:							int				=      0
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							List[str]				=      ids_tensor([self.batch_size, self.seq_length]     ,      self.vocab_size      )
										__magic_name__				:							Tuple				=      random_attention_mask([self.batch_size, self.seq_length]     ,      dtype=tf.floataa      )

										__magic_name__				:							Optional[int]				=      None
										if self.use_input_lengths:
																__magic_name__				:							List[str]				=      (
																    ids_tensor([self.batch_size]     ,      vocab_size=2      ) + self.seq_length - 2
																)  # small variation of seq_length

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

										__magic_name__				:							Optional[int]				=      None
										__magic_name__				:							Any				=      None
										__magic_name__				:							Tuple				=      None
										if self.use_labels:
																__magic_name__				:							str				=      ids_tensor([self.batch_size]     ,      self.type_sequence_label_size      )
																__magic_name__				:							Optional[int]				=      ids_tensor([self.batch_size, self.seq_length]     ,      self.num_labels      )
																__magic_name__				:							Optional[Any]				=      ids_tensor([self.batch_size]     ,      2     ,      dtype=tf.floataa      )
																__magic_name__				:							List[Any]				=      ids_tensor([self.batch_size]     ,      self.num_choices      )

										__magic_name__				:							Any				=      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  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      ):




										"""simple docstring"""




										__magic_name__				:							Tuple				=      TFXLMModel(config=_UpperCAmelCase      )
										__magic_name__				:							Tuple				=      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
										__magic_name__				:							List[str]				=      model(_UpperCAmelCase      )

										__magic_name__				:							Tuple				=      [input_ids, input_mask]
										__magic_name__				:							Optional[Any]				=      model(_UpperCAmelCase      )
										self.parent.assertEqual(result.last_hidden_state.shape     ,      (self.batch_size, self.seq_length, self.hidden_size)      )
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      ):




										"""simple docstring"""




										__magic_name__				:							List[str]				=      TFXLMWithLMHeadModel(_UpperCAmelCase      )

										__magic_name__				:							str				=      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
										__magic_name__				:							Optional[Any]				=      model(_UpperCAmelCase      )

										__magic_name__				:							List[Any]				=      outputs

										self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.seq_length, self.vocab_size)      )
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      ):




										"""simple docstring"""




										__magic_name__				:							str				=      TFXLMForQuestionAnsweringSimple(_UpperCAmelCase      )

										__magic_name__				:							str				=      {'input_ids': input_ids, 'lengths': input_lengths}

										__magic_name__				:							Tuple				=      model(_UpperCAmelCase      )

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




										"""simple docstring"""




										__magic_name__				:							Optional[Any]				=      TFXLMForSequenceClassification(_UpperCAmelCase      )

										__magic_name__				:							List[Any]				=      {'input_ids': input_ids, 'lengths': input_lengths}

										__magic_name__				:							List[Any]				=      model(_UpperCAmelCase      )

										self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.type_sequence_label_size)      )
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      ):




										"""simple docstring"""




										__magic_name__				:							Optional[int]				=      self.num_labels
										__magic_name__				:							List[str]				=      TFXLMForTokenClassification(config=_UpperCAmelCase      )
										__magic_name__				:							List[Any]				=      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
										__magic_name__				:							Union[str, Any]				=      model(_UpperCAmelCase      )
										self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.seq_length, self.num_labels)      )
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      ):




										"""simple docstring"""




										__magic_name__				:							Tuple				=      self.num_choices
										__magic_name__				:							Union[str, Any]				=      TFXLMForMultipleChoice(config=_UpperCAmelCase      )
										__magic_name__				:							Optional[int]				=      tf.tile(tf.expand_dims(_UpperCAmelCase     ,      1      )     ,      (1, self.num_choices, 1)      )
										__magic_name__				:							List[str]				=      tf.tile(tf.expand_dims(_UpperCAmelCase     ,      1      )     ,      (1, self.num_choices, 1)      )
										__magic_name__				:							Tuple				=      tf.tile(tf.expand_dims(_UpperCAmelCase     ,      1      )     ,      (1, self.num_choices, 1)      )
										__magic_name__				:							int				=      {
										    'input_ids': multiple_choice_inputs_ids,
										    'attention_mask': multiple_choice_input_mask,
										    'token_type_ids': multiple_choice_token_type_ids,
										}
										__magic_name__				:							Optional[Any]				=      model(_UpperCAmelCase      )
										self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.num_choices)      )





				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							Union[str, Any]				=      self.prepare_config_and_inputs()
										(
										    __magic_name__ 
										)				:							Optional[int]				=      config_and_inputs
										__magic_name__				:							Union[str, Any]				=      {
										    'input_ids': input_ids,
										    'token_type_ids': token_type_ids,
										    'langs': token_type_ids,
										    'lengths': input_lengths,
										}
										return config, inputs_dict






@require_tf
class     snake_case__  (      _A						,       _A						,       unittest.TestCase  ):
				__lowerCAmelCase		=      (
				    (
				        TFXLMModel,
				        TFXLMWithLMHeadModel,
				        TFXLMForSequenceClassification,
				        TFXLMForQuestionAnsweringSimple,
				        TFXLMForTokenClassification,
				        TFXLMForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				__lowerCAmelCase		=      (
				    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				__lowerCAmelCase		=      (
				    {
				        '''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 {}
				)
				__lowerCAmelCase		=      False
				__lowerCAmelCase		=      False
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase      ):




										"""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  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							int				=      TFXLMModelTester(self      )
										__magic_name__				:							Union[str, Any]				=      ConfigTester(self     ,      config_class=_UpperCAmelCase     ,      emb_dim=37      )
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										self.config_tester.run_common_tests()
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							str				=      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_model(*_UpperCAmelCase      )
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							int				=      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*_UpperCAmelCase      )
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							Union[str, Any]				=      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*_UpperCAmelCase      )
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							Any				=      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*_UpperCAmelCase      )
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							Any				=      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_token_classification(*_UpperCAmelCase      )
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							str				=      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*_UpperCAmelCase      )





				@slow
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__magic_name__				:							int				=      TFXLMModel.from_pretrained(_UpperCAmelCase      )
																self.assertIsNotNone(_UpperCAmelCase      )






@require_tf
class     snake_case__  (      unittest.TestCase  ):
				@slow
				def  UpperCamelCase_						(  self      ):




										"""simple docstring"""




										__magic_name__				:							Optional[int]				=      TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'      )
										__magic_name__				:							Tuple				=      tf.convert_to_tensor([[14, 447]]     ,      dtype=tf.intaa      )  # the president
										__magic_name__				:							Union[str, Any]				=      [
										    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
										__magic_name__				:							str				=      model.generate(_UpperCAmelCase     ,      do_sample=_UpperCAmelCase      )
										self.assertListEqual(output_ids[0].numpy().tolist()     ,      _UpperCAmelCase      )






from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

# Load iris file
snake_case__     							= load_iris()
iris.keys()


print(F"""Target names: \n {iris.target_names} """)
print(F"""\n Features: \n {iris.feature_names}""")

# Train set e Test set
snake_case__							,     snake_case__							,     snake_case__							,     snake_case__     							= train_test_split(
    iris['data'], iris['target'], random_state=4
)

# KNN

snake_case__     							= KNeighborsClassifier(n_neighbors=1)
knn.fit(X_train, y_train)

# new array to test
snake_case__     							= [[1, 2, 1, 4], [2, 3, 4, 5]]

snake_case__     							= knn.predict(X_new)

print(
    F"""\nNew array: \n {X_new}\n\nTarget Names Prediction: \n"""
    F""" {iris['target_names'][prediction]}"""
)


