





import unittest

from transformers import ErnieMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    ErnieMForInformationExtraction,
							    ErnieMForMultipleChoice,
							    ErnieMForQuestionAnswering,
							    ErnieMForSequenceClassification,
							    ErnieMForTokenClassification,
							    ErnieMModel,
							)
							from transformers.models.ernie_m.modeling_ernie_m import ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST

class 					__A   :


				def __init__(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_=13      ,       UpperCAmelCase_=7      ,       UpperCAmelCase_=True      ,       UpperCAmelCase_=True      ,       UpperCAmelCase_=True      ,       UpperCAmelCase_=99      ,       UpperCAmelCase_=32      ,       UpperCAmelCase_=5      ,       UpperCAmelCase_=4      ,       UpperCAmelCase_=37      ,       UpperCAmelCase_="gelu"      ,       UpperCAmelCase_=0.1      ,       UpperCAmelCase_=0.1      ,       UpperCAmelCase_=512      ,       UpperCAmelCase_=16      ,       UpperCAmelCase_=2      ,       UpperCAmelCase_=0.0_2      ,       UpperCAmelCase_=3      ,       UpperCAmelCase_=4      ,       UpperCAmelCase_=None      ,       ):
								lowerCamelCase		       =parent
								lowerCamelCase		       =batch_size
								lowerCamelCase		       =seq_length
								lowerCamelCase		       =is_training
								lowerCamelCase		       =use_input_mask
								lowerCamelCase		       =use_labels
								lowerCamelCase		       =vocab_size
								lowerCamelCase		       =hidden_size
								lowerCamelCase		       =num_hidden_layers
								lowerCamelCase		       =num_attention_heads
								lowerCamelCase		       =intermediate_size
								lowerCamelCase		       =hidden_act
								lowerCamelCase		       =hidden_dropout_prob
								lowerCamelCase		       =attention_probs_dropout_prob
								lowerCamelCase		       =max_position_embeddings
								lowerCamelCase		       =type_vocab_size
								lowerCamelCase		       =type_sequence_label_size
								lowerCamelCase		       =initializer_range
								lowerCamelCase		       =num_labels
								lowerCamelCase		       =num_choices
								lowerCamelCase		       =scope


				def _snake_case				(						self							):
								lowerCamelCase		       =ids_tensor([self.batch_size, self.seq_length]      ,       self.vocab_size							)

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

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

								lowerCamelCase		       =self.get_config()

								return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


				def _snake_case				(						self							):
								lowerCamelCase		       =ids_tensor([self.batch_size, self.seq_length]      ,       self.vocab_size							)

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

								return config, input_ids, input_mask


				def _snake_case				(						self							):
								return ErnieMConfig(
								    vocab_size=self.vocab_size      ,       hidden_size=self.hidden_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      ,       )


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								lowerCamelCase		       =ErnieMModel(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase		       =model(UpperCAmelCase_      ,       return_dict=UpperCAmelCase_							)
								self.parent.assertEqual(result.last_hidden_state.shape      ,       (self.batch_size, self.seq_length, self.hidden_size)							)


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								lowerCamelCase		       =ErnieMForQuestionAnswering(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase		       =model(
								    UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_      ,       start_positions=UpperCAmelCase_      ,       end_positions=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 _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								lowerCamelCase		       =ErnieMForInformationExtraction(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase		       =torch.ones_like(UpperCAmelCase_      ,       dtype=torch.floataa							)
								lowerCamelCase		       =model(
								    UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_      ,       start_positions=UpperCAmelCase_      ,       end_positions=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 _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								lowerCamelCase		       =self.num_labels
								lowerCamelCase		       =ErnieMForSequenceClassification(UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase		       =model(UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_      ,       labels=UpperCAmelCase_							)
								self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_labels)							)


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								lowerCamelCase		       =self.num_labels
								lowerCamelCase		       =ErnieMForTokenClassification(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								input_ids.to(UpperCAmelCase_							)
								input_mask.to(UpperCAmelCase_							)
								token_labels.to(UpperCAmelCase_							)

								lowerCamelCase		       =model(UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_      ,       labels=UpperCAmelCase_							)

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


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								lowerCamelCase		       =self.num_choices
								lowerCamelCase		       =ErnieMForMultipleChoice(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase		       =input_ids.unsqueeze(1							).expand(-1      ,       self.num_choices      ,       -1							).contiguous()
								lowerCamelCase		       =input_mask.unsqueeze(1							).expand(-1      ,       self.num_choices      ,       -1							).contiguous()
								lowerCamelCase		       =model(
								    UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_      ,       labels=UpperCAmelCase_      ,       )
								self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_choices)							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.prepare_config_and_inputs()
								(
								    (
								    lowerCamelCase
								)       ,     (
								    lowerCamelCase
								)       ,     (
								    lowerCamelCase
								)       ,     (
								    lowerCamelCase
								)       ,     (
								    lowerCamelCase
								)       ,     (
								    lowerCamelCase
								)       ,     
								)		       =config_and_inputs
								lowerCamelCase		       ={"""input_ids""": input_ids, """attention_mask""": input_mask}
								return config, inputs_dict




@require_torch
class 					__A   (  a			,    a			,    unittest.TestCase			):
				__A            = (
				    (
				        ErnieMModel,
				        ErnieMForMultipleChoice,
				        ErnieMForQuestionAnswering,
				        ErnieMForSequenceClassification,
				        ErnieMForTokenClassification,
				    )
				    if is_torch_available()
				    else ()
				)
				__A            = ()
				__A            = (
				    {
				        """feature-extraction""": ErnieMModel,
				        """question-answering""": ErnieMForQuestionAnswering,
				        """text-classification""": ErnieMForSequenceClassification,
				        """token-classification""": ErnieMForTokenClassification,
				        """zero-shot""": ErnieMForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				__A            = False


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								if pipeline_test_casse_name == "QAPipelineTests":
												return True

								return False


				def _snake_case				(						self							):
								lowerCamelCase		       =ErnieMModelTester(self							)
								lowerCamelCase		       =ConfigTester(self      ,       config_class=UpperCAmelCase_      ,       hidden_size=37							)


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


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase_							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
												lowerCamelCase		       =type
												self.model_tester.create_and_check_model(*UpperCAmelCase_							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*UpperCAmelCase_							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase_							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase_							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_information_extraction(*UpperCAmelCase_							)


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase_							)


				@slow
				def _snake_case				(						self							):
								for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowerCamelCase		       =ErnieMModel.from_pretrained(UpperCAmelCase_							)
												self.assertIsNotNone(UpperCAmelCase_							)




@require_torch
class 					__A   (  unittest.TestCase			):


				@slow
				def _snake_case				(						self							):
								lowerCamelCase		       =ErnieMModel.from_pretrained("""susnato/ernie-m-base_pytorch"""							)
								model.eval()
								lowerCamelCase		       =torch.tensor([[0, 1, 2, 3, 4, 5]]							)
								lowerCamelCase		       =model(UpperCAmelCase_							)[0]

								# TODO Replace vocab size
								lowerCamelCase		       =768

								lowerCamelCase		       =torch.Size((1, 6, hidden_size)							)
								self.assertEqual(output.shape      ,       UpperCAmelCase_							)

								lowerCamelCase		       =torch.tensor(
								    [[[-0.0_0_1_2, 0.1_2_4_5, -0.0_2_1_4], [-0.0_7_4_2, 0.0_2_4_4, -0.0_7_7_1], [-0.0_3_3_3, 0.1_1_6_4, -0.1_5_5_4]]]							)

								self.assertTrue(torch.allclose(output[:, :3, :3]      ,       UpperCAmelCase_      ,       atol=1E-3							)							)








from __future__ import annotations

from collections.abc import Generator



def    UpperCamelCase(					lowercase_							)	->				Generator[int, None, None]:





  '''simple docstring'''





  if not isinstance(lowercase_			,					lowercase_							) or n < 1:
    raise Exception("""Sequence only defined for positive integers"""							)

  yield n
  while n != 1:
    if n % 2 == 0:
      n //= 2
    else:
      snake_case_       						=      3 * n + 1
    yield n



def    UpperCamelCase(					)	->				Optional[int]:





  '''simple docstring'''





  snake_case_       						=      43
  snake_case_       						=      tuple(collatz_sequence(lowercase_							)							)
  print(lowercase_							)
  print(f'''Collatz sequence from {n} took {len(lowercase_							)} steps.'''							)


if __name__ == "__main__":
    main()