




'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


a  :				Tuple									=  {
    'configuration_mobilebert': [
        'MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'MobileBertConfig',
        'MobileBertOnnxConfig',
    ],
    'tokenization_mobilebert': ['MobileBertTokenizer'],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							a  :				Tuple									=  ['MobileBertTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							a  :				Union[str, Any]									=  [
							    'MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'MobileBertForMaskedLM',
							    'MobileBertForMultipleChoice',
							    'MobileBertForNextSentencePrediction',
							    'MobileBertForPreTraining',
							    'MobileBertForQuestionAnswering',
							    'MobileBertForSequenceClassification',
							    'MobileBertForTokenClassification',
							    'MobileBertLayer',
							    'MobileBertModel',
							    'MobileBertPreTrainedModel',
							    'load_tf_weights_in_mobilebert',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							a  :				List[Any]									=  [
							    'TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TFMobileBertForMaskedLM',
							    'TFMobileBertForMultipleChoice',
							    'TFMobileBertForNextSentencePrediction',
							    'TFMobileBertForPreTraining',
							    'TFMobileBertForQuestionAnswering',
							    'TFMobileBertForSequenceClassification',
							    'TFMobileBertForTokenClassification',
							    'TFMobileBertMainLayer',
							    'TFMobileBertModel',
							    'TFMobileBertPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_mobilebert import (
							    MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    MobileBertConfig,
							    MobileBertOnnxConfig,
							)
							from .tokenization_mobilebert import MobileBertTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_mobilebert_fast import MobileBertTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mobilebert import (
														    MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    MobileBertForMaskedLM,
														    MobileBertForMultipleChoice,
														    MobileBertForNextSentencePrediction,
														    MobileBertForPreTraining,
														    MobileBertForQuestionAnswering,
														    MobileBertForSequenceClassification,
														    MobileBertForTokenClassification,
														    MobileBertLayer,
														    MobileBertModel,
														    MobileBertPreTrainedModel,
														    load_tf_weights_in_mobilebert,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_mobilebert import (
														    TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFMobileBertForMaskedLM,
														    TFMobileBertForMultipleChoice,
														    TFMobileBertForNextSentencePrediction,
														    TFMobileBertForPreTraining,
														    TFMobileBertForQuestionAnswering,
														    TFMobileBertForSequenceClassification,
														    TFMobileBertForTokenClassification,
														    TFMobileBertMainLayer,
														    TFMobileBertModel,
														    TFMobileBertPreTrainedModel,
														)

else:
							import sys

							a  :				List[Any]									=  _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


import unittest

from transformers import GPTNeoXJapaneseConfig, is_torch_available
from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import GPTNeoXJapaneseTokenizer
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 GPTNeoXJapaneseForCausalLM, GPTNeoXJapaneseModel







class __snake_case				:




   def __init__(    self			:				Optional[int]       ,	_lowercase			:				Union[str, Any]       ,	_lowercase			:				List[Any]=13       ,	_lowercase			:				List[Any]=7       ,	_lowercase			:				Optional[int]=True       ,	_lowercase			:				str=True       ,	_lowercase			:				str=True       ,	_lowercase			:				List[str]=True       ,	_lowercase			:				List[str]=99       ,	_lowercase			:				List[str]=32       ,	_lowercase			:				str=5       ,	_lowercase			:				str=4       ,	_lowercase			:				str=4       ,	_lowercase			:				Union[str, Any]="gelu"       ,	_lowercase			:				str=0.0       ,	_lowercase			:				Union[str, Any]=0.1       ,	_lowercase			:				List[str]=True       ,	_lowercase			:				Union[str, Any]=5_12       ,	_lowercase			:				List[str]=16       ,	_lowercase			:				Dict=2       ,	_lowercase			:				int=0.02       ,	_lowercase			:				Any=3       ,	_lowercase			:				int=4       ,	_lowercase			:				List[str]=None       ,	):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      parent
     SCREAMING_SNAKE_CASE__										=      batch_size
     SCREAMING_SNAKE_CASE__										=      seq_length
     SCREAMING_SNAKE_CASE__										=      is_training
     SCREAMING_SNAKE_CASE__										=      use_input_mask
     SCREAMING_SNAKE_CASE__										=      use_token_type_ids
     SCREAMING_SNAKE_CASE__										=      use_labels
     SCREAMING_SNAKE_CASE__										=      vocab_size
     SCREAMING_SNAKE_CASE__										=      hidden_size
     SCREAMING_SNAKE_CASE__										=      num_hidden_layers
     SCREAMING_SNAKE_CASE__										=      num_attention_heads
     SCREAMING_SNAKE_CASE__										=      intermediate_multiple_size
     SCREAMING_SNAKE_CASE__										=      hidden_act
     SCREAMING_SNAKE_CASE__										=      hidden_dropout
     SCREAMING_SNAKE_CASE__										=      attention_dropout
     SCREAMING_SNAKE_CASE__										=      weight_tying
     SCREAMING_SNAKE_CASE__										=      max_position_embeddings
     SCREAMING_SNAKE_CASE__										=      type_vocab_size
     SCREAMING_SNAKE_CASE__										=      type_sequence_label_size
     SCREAMING_SNAKE_CASE__										=      initializer_range
     SCREAMING_SNAKE_CASE__										=      num_labels
     SCREAMING_SNAKE_CASE__										=      num_choices
     SCREAMING_SNAKE_CASE__										=      scope




   def 	__a						(    self			:				List[Any]      ):



     """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_labels:
       SCREAMING_SNAKE_CASE__										=      ids_tensor([self.batch_size, self.seq_length]       ,	self.num_labels      )

     SCREAMING_SNAKE_CASE__										=      self.get_config()

     return config, input_ids, input_mask, token_labels




   def 	__a						(    self			:				Optional[int]      ):



     """simple docstring"""






     return GPTNeoXJapaneseConfig(
         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_multiple_size=self.intermediate_multiple_size       ,	hidden_act=self.hidden_act       ,	hidden_dropout=self.hidden_dropout       ,	attention_dropout=self.attention_dropout       ,	weight_tying=self.weight_tying       ,	max_position_embeddings=self.max_position_embeddings       ,	type_vocab_size=self.type_vocab_size       ,	is_decoder=_lowercase       ,	initializer_range=self.initializer_range       ,	)




   def 	__a						(    self			:				Optional[int]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__										=      self.prepare_config_and_inputs()

     SCREAMING_SNAKE_CASE__										=      True

     return config, input_ids, input_mask, token_labels




   def 	__a						(    self			:				List[Any]       ,	_lowercase			:				Optional[Any]       ,	_lowercase			:				int       ,	_lowercase			:				List[Any]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      GPTNeoXJapaneseModel(config=_lowercase      )
     model.to(_lowercase      )
     model.eval()
     SCREAMING_SNAKE_CASE__										=      model(_lowercase       ,	attention_mask=_lowercase      )
     SCREAMING_SNAKE_CASE__										=      model(_lowercase      )
     self.parent.assertEqual(result.last_hidden_state.shape       ,	(self.batch_size, self.seq_length, self.hidden_size)      )




   def 	__a						(    self			:				Dict       ,	_lowercase			:				int       ,	_lowercase			:				str       ,	_lowercase			:				Any      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      True
     SCREAMING_SNAKE_CASE__										=      GPTNeoXJapaneseModel(_lowercase      )
     model.to(_lowercase      )
     model.eval()
     SCREAMING_SNAKE_CASE__										=      model(_lowercase       ,	attention_mask=_lowercase      )
     self.parent.assertEqual(result.last_hidden_state.shape       ,	(self.batch_size, self.seq_length, self.hidden_size)      )




   def 	__a						(    self			:				Any       ,	_lowercase			:				Dict       ,	_lowercase			:				List[Any]       ,	_lowercase			:				Optional[Any]       ,	_lowercase			:				Dict      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      GPTNeoXJapaneseForCausalLM(config=_lowercase      )
     model.to(_lowercase      )
     model.eval()
     SCREAMING_SNAKE_CASE__										=      model(_lowercase       ,	attention_mask=_lowercase       ,	labels=_lowercase      )
     self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.vocab_size)      )




   def 	__a						(    self			:				int       ,	_lowercase			:				Dict       ,	_lowercase			:				Optional[Any]       ,	_lowercase			:				int      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      True
     SCREAMING_SNAKE_CASE__										=      GPTNeoXJapaneseForCausalLM(config=_lowercase      )
     model.to(_lowercase      )
     model.eval()

     # first forward pass
     SCREAMING_SNAKE_CASE__										=      model(_lowercase       ,	attention_mask=_lowercase       ,	use_cache=_lowercase      )
     SCREAMING_SNAKE_CASE__										=      outputs.past_key_values

     # create hypothetical multiple next token and extent to next_input_ids
     SCREAMING_SNAKE_CASE__										=      ids_tensor((self.batch_size, 3)       ,	config.vocab_size      )
     SCREAMING_SNAKE_CASE__										=      ids_tensor((self.batch_size, 3)       ,	vocab_size=2      )

     # append to next input_ids and
     SCREAMING_SNAKE_CASE__										=      torch.cat([input_ids, next_tokens]       ,	dim=-1      )
     SCREAMING_SNAKE_CASE__										=      torch.cat([input_mask, next_mask]       ,	dim=-1      )

     SCREAMING_SNAKE_CASE__										=      model(_lowercase       ,	attention_mask=_lowercase       ,	output_hidden_states=_lowercase      )
     SCREAMING_SNAKE_CASE__										=      output_from_no_past["""hidden_states"""][0]
     SCREAMING_SNAKE_CASE__										=      model(
         _lowercase       ,	attention_mask=_lowercase       ,	past_key_values=_lowercase       ,	output_hidden_states=_lowercase       ,	)["""hidden_states"""][0]

     # select random slice
     SCREAMING_SNAKE_CASE__										=      ids_tensor((1,)       ,	output_from_past.shape[-1]      ).item()
     SCREAMING_SNAKE_CASE__										=      output_from_no_past[:, -3:, random_slice_idx].detach()
     SCREAMING_SNAKE_CASE__										=      output_from_past[:, :, random_slice_idx].detach()

     self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]      )

     # test that outputs are equal for slice
     self.parent.assertTrue(torch.allclose(_lowercase       ,	_lowercase       ,	atol=1E-3      )      )




   def 	__a						(    self			:				str      ):



     """simple docstring"""






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







@require_torch
class __snake_case				(						lowerCamelCase_   ,		lowerCamelCase_   ,		unittest.TestCase		):
   lowerCAmelCase_														=							(GPTNeoXJapaneseModel, GPTNeoXJapaneseForCausalLM) if is_torch_available() else ()
   lowerCAmelCase_														=							(GPTNeoXJapaneseForCausalLM,) if is_torch_available() else ()
   lowerCAmelCase_														=							(
       {"feature-extraction": GPTNeoXJapaneseModel, "text-generation": GPTNeoXJapaneseForCausalLM}
       if is_torch_available()
       else {}
   )
   lowerCAmelCase_														=							False
   lowerCAmelCase_														=							False
   lowerCAmelCase_														=							False
   lowerCAmelCase_														=							False




   def 	__a						(    self			:				List[str]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      GPTNeoXJapaneseModelTester(self      )
     SCREAMING_SNAKE_CASE__										=      ConfigTester(self       ,	config_class=_lowercase       ,	hidden_size=37      )




   def 	__a						(    self			:				Tuple      ):



     """simple docstring"""






     self.config_tester.run_common_tests()




   def 	__a						(    self			:				Optional[int]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__										=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(_lowercase       ,	_lowercase       ,	_lowercase      )




   def 	__a						(    self			:				Union[str, Any]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__										=      self.model_tester.prepare_config_and_inputs_for_decoder()
     self.model_tester.create_and_check_model_as_decoder(_lowercase       ,	_lowercase       ,	_lowercase      )




   def 	__a						(    self			:				str      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__										=      self.model_tester.prepare_config_and_inputs_for_decoder()

     SCREAMING_SNAKE_CASE__										=      None

     self.model_tester.create_and_check_model_as_decoder(_lowercase       ,	_lowercase       ,	_lowercase      )




   def 	__a						(    self			:				Union[str, Any]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__										=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_decoder_model_past_large_inputs(_lowercase       ,	_lowercase       ,	_lowercase      )




   def 	__a						(    self			:				List[Any]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_causal_lm(*_lowercase      )




   @slow
   def 	__a						(    self			:				Any      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      """abeja/gpt-neox-japanese-2.7b"""

     SCREAMING_SNAKE_CASE__										=      ["""データサイエンティストとは、""", """100年後に必要とされる会社は、""", """フルリモートの環境で働くために必要なことは、""", """国境の長いトンネルを抜けると""", """美味しい日本食といえば、"""]

     SCREAMING_SNAKE_CASE__										=      [
         """データサイエンティストとは、データを分析し、ビジネスに役立つ知見を導き出す専門家のことです。""",
         """100年後に必要とされる会社は、「人」が中心の会社です。""",
         """フルリモートの環境で働くために必要なことは、「自分の時間をコントロールする」ことです。""",
         """国境の長いトンネルを抜けると、そこは雪国だった。""",
         """美味しい日本食といえば、やっぱりお寿司ですよね。""",
     ]

     SCREAMING_SNAKE_CASE__										=      GPTNeoXJapaneseTokenizer.from_pretrained(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      GPTNeoXJapaneseForCausalLM.from_pretrained(_lowercase      )

     SCREAMING_SNAKE_CASE__										=      []
     for prompt in prompts:
       SCREAMING_SNAKE_CASE__										=      tokenizer(_lowercase       ,	return_tensors="""pt"""      ).input_ids
       SCREAMING_SNAKE_CASE__										=      model.generate(_lowercase       ,	max_length=50      )
       SCREAMING_SNAKE_CASE__										=      tokenizer.batch_decode(_lowercase       ,	skip_special_tokens=_lowercase      )
       predicted_outputs += generated_string
     self.assertListEqual(_lowercase       ,	_lowercase      )
