


'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


__magic_name__			=      logging.get_logger(__name__)

__magic_name__			=      {
    'facebook/nllb-moe-54B': 'https://huggingface.co/facebook/nllb-moe-54b/resolve/main/config.json',
}



class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE    ):


  '''simple docstring'''







  a_  					=							"""nllb-moe"""
  a_  					=							["""past_key_values"""]
  a_  					=							{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}






  def __init__(							self :       Union[str, Any]	,_a :       Dict=128112	,_a :       Union[str, Any]=1024	,_a :       Any=12	,_a :       Tuple=4096	,_a :       Optional[int]=16	,_a :       str=12	,_a :       Optional[Any]=4096	,_a :       List[Any]=16	,_a :       Dict=0.05	,_a :       Tuple=0.05	,_a :       List[Any]=True	,_a :       str=True	,_a :       Union[str, Any]="relu"	,_a :       Optional[Any]=1024	,_a :       Optional[Any]=0.1	,_a :       Optional[Any]=0.1	,_a :       List[Any]=0.0	,_a :       Optional[Any]=0.02	,_a :       List[Any]=2	,_a :       Optional[int]=True	,_a :       Optional[Any]=False	,_a :       Union[str, Any]="float32"	,_a :       Union[str, Any]=False	,_a :       List[str]=128	,_a :       Optional[int]=64	,_a :       List[str]=4	,_a :       Tuple=4	,_a :       int=0.001	,_a :       Any=0.001	,_a :       Union[str, Any]="all"	,_a :       int=False	,_a :       List[str]=False	,_a :       Dict=1.0	,_a :       Any=0.2	,_a :       Dict=1	,_a :       int=0	,_a :       Optional[Any]=2	,_a :       Any=False	,**_a :       List[str]	,):

        '''simple docstring'''




        A_						:  int          =				vocab_size
        A_						:  int          =				max_position_embeddings
        A_						:  Any          =				d_model
        A_						:  List[Any]          =				encoder_ffn_dim
        A_						:  Dict          =				encoder_layers
        A_						:  Union[str, Any]          =				encoder_attention_heads
        A_						:  int          =				decoder_ffn_dim
        A_						:  List[Any]          =				decoder_layers
        A_						:  Optional[int]          =				decoder_attention_heads
        A_						:  Tuple          =				dropout
        A_						:  int          =				attention_dropout
        A_						:  Optional[Any]          =				activation_dropout
        A_						:  Tuple          =				activation_function
        A_						:  Any          =				init_std
        A_						:  str          =				encoder_layerdrop
        A_						:  str          =				decoder_layerdrop
        A_						:  Optional[Any]          =				use_cache
        A_						:  int          =				encoder_layers
        A_						:  Dict          =				scale_embedding  # scale factor will be sqrt(d_model) if True
        A_						:  Any          =				router_z_loss_coef
        A_						:  Tuple          =				router_aux_loss_coef
        A_						:  List[Any]          =				decoder_sparse_step
        A_						:  Optional[int]          =				encoder_sparse_step
        A_						:  Any          =				num_experts
        A_						:  Optional[Any]          =				expert_capacity
        A_						:  Optional[Any]          =				router_bias
        if router_dtype not in ["float32", "float16", "bfloat16"]:
              raise ValueError(f'`router_dtype` must be one of \'float32\', \'float16\' or \'bfloat16\', got {router_dtype}' )
        A_						:  Tuple          =				router_dtype

        A_						:  Any          =				router_ignore_padding_tokens
        A_						:  Any          =				batch_prioritized_routing
        A_						:  Tuple          =				second_expert_policy
        A_						:  Dict          =				normalize_router_prob_before_dropping
        A_						:  Any          =				moe_eval_capacity_token_fraction
        A_						:  Optional[Any]          =				moe_token_dropout
        A_						:  List[str]          =				output_router_logits
        super().__init__(
            pad_token_id=_a	,bos_token_id=_a	,eos_token_id=_a	,is_encoder_decoder=_a	,decoder_start_token_id=_a	,**_a	,)




'''simple docstring'''


import unittest

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

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
         OpenAIGPTConfig,
         OpenAIGPTDoubleHeadsModel,
         OpenAIGPTForSequenceClassification,
         OpenAIGPTLMHeadModel,
         OpenAIGPTModel,
     )



class 	__lowerCAmelCase		:


  '''simple docstring'''







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

        '''simple docstring'''




        A_						:  Optional[Any]          =				parent
        A_						:  str          =				batch_size
        A_						:  int          =				seq_length
        A_						:  Union[str, Any]          =				is_training
        A_						:  Optional[Any]          =				use_token_type_ids
        A_						:  int          =				use_labels
        A_						:  Dict          =				vocab_size
        A_						:  List[Any]          =				hidden_size
        A_						:  Tuple          =				num_hidden_layers
        A_						:  Optional[int]          =				num_attention_heads
        A_						:  int          =				intermediate_size
        A_						:  Tuple          =				hidden_act
        A_						:  int          =				hidden_dropout_prob
        A_						:  Dict          =				attention_probs_dropout_prob
        A_						:  Any          =				max_position_embeddings
        A_						:  Optional[Any]          =				type_vocab_size
        A_						:  Tuple          =				type_sequence_label_size
        A_						:  int          =				initializer_range
        A_						:  Optional[Any]          =				num_labels
        A_						:  str          =				num_choices
        A_						:  Optional[Any]          =				scope
        A_						:  List[Any]          =				self.vocab_size - 1






  def        _a							(							self :       Any ):

        '''simple docstring'''




        A_						:  List[Any]          =				ids_tensor([self.batch_size, self.seq_length]	,self.vocab_size )

        A_						:  List[Any]          =				None
        if self.use_token_type_ids:
              A_						:  Optional[int]          =				ids_tensor([self.batch_size, self.seq_length]	,self.type_vocab_size )

        A_						:  int          =				None
        A_						:  str          =				None
        A_						:  Union[str, Any]          =				None
        if self.use_labels:
              A_						:  Optional[int]          =				ids_tensor([self.batch_size]	,self.type_sequence_label_size )
              A_						:  str          =				ids_tensor([self.batch_size, self.seq_length]	,self.num_labels )
              A_						:  Any          =				ids_tensor([self.batch_size]	,self.num_choices )

        A_						:  List[Any]          =				OpenAIGPTConfig(
            vocab_size=self.vocab_size	,n_embd=self.hidden_size	,n_layer=self.num_hidden_layers	,n_head=self.num_attention_heads	,n_positions=self.max_position_embeddings	,pad_token_id=self.pad_token_id	,)

        A_						:  Tuple          =				ids_tensor([self.num_hidden_layers, self.num_attention_heads]	,2 )

        return (
            config,
            input_ids,
            head_mask,
            token_type_ids,
            sequence_labels,
            token_labels,
            choice_labels,
        )






  def        _a							(							self :       Optional[int]	,_a :       List[str]	,_a :       str	,_a :       int	,_a :       int	,*_a :       Union[str, Any] ):

        '''simple docstring'''




        A_						:  Optional[Any]          =				OpenAIGPTModel(config=_a )
        model.to(_a )
        model.eval()

        A_						:  Optional[int]          =				model(_a	,token_type_ids=_a	,head_mask=_a )
        A_						:  str          =				model(_a	,token_type_ids=_a )
        A_						:  Dict          =				model(_a )

        self.parent.assertEqual(result.last_hidden_state.shape	,(self.batch_size, self.seq_length, self.hidden_size) )






  def        _a							(							self :       Dict	,_a :       Optional[int]	,_a :       Union[str, Any]	,_a :       Dict	,_a :       List[str]	,*_a :       str ):

        '''simple docstring'''




        A_						:  str          =				OpenAIGPTLMHeadModel(_a )
        model.to(_a )
        model.eval()

        A_						:  Any          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.loss.shape	,() )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size) )






  def        _a							(							self :       Any	,_a :       Dict	,_a :       List[Any]	,_a :       Dict	,_a :       Union[str, Any]	,*_a :       str ):

        '''simple docstring'''




        A_						:  Any          =				OpenAIGPTDoubleHeadsModel(_a )
        model.to(_a )
        model.eval()

        A_						:  Optional[int]          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.loss.shape	,() )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size) )






  def        _a							(							self :       List[str]	,_a :       str	,_a :       Tuple	,_a :       Dict	,_a :       Tuple	,*_a :       Dict ):

        '''simple docstring'''




        A_						:  List[str]          =				self.num_labels
        A_						:  int          =				OpenAIGPTForSequenceClassification(_a )
        model.to(_a )
        model.eval()

        A_						:  Dict          =				ids_tensor([self.batch_size]	,self.type_sequence_label_size )
        A_						:  Optional[Any]          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_labels) )






  def        _a							(							self :       Tuple ):

        '''simple docstring'''




        A_						:  Union[str, Any]          =				self.prepare_config_and_inputs()
        (
            (
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					
        )						:  str          =				config_and_inputs
        A_						:  int          =				{
            """input_ids""": input_ids,
            """token_type_ids""": token_type_ids,
            """head_mask""": head_mask,
        }

        return config, inputs_dict







@require_torch
class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE  , __SCREAMING_SNAKE_CASE  , __SCREAMING_SNAKE_CASE  , unittest.TestCase    ):


  '''simple docstring'''







  a_  					=							(
      (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
      if is_torch_available()
      else ()
  )
  a_  					=							(
      (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
  )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
  a_  					=							(
      {
          """feature-extraction""": OpenAIGPTModel,
          """text-classification""": OpenAIGPTForSequenceClassification,
          """text-generation""": OpenAIGPTLMHeadModel,
          """zero-shot""": OpenAIGPTForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )






  def        _a							(							self :       Tuple	,_a :       Optional[int]	,_a :       str	,_a :       List[str]	,_a :       List[str]	,_a :       Any ):

        '''simple docstring'''




        if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
              # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
              # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
              # tiny config could not be created.
              return True

        return False






  def        _a							(							self :       Optional[int]	,_a :       str	,_a :       Dict	,_a :       Optional[int]=False ):

        '''simple docstring'''




        A_						:  Any          =				super()._prepare_for_class(_a	,_a	,return_labels=_a )

        if return_labels:
              if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
                    A_						:  Union[str, Any]          =				torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)	,dtype=torch.long	,device=_a	,)
                    A_						:  Any          =				inputs_dict["""labels"""]
                    A_						:  Any          =				inputs_dict["""labels"""]
                    A_						:  Tuple          =				torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.num_choices)	,dtype=torch.long	,device=_a	,)
                    A_						:  int          =				torch.zeros(
                        self.model_tester.batch_size	,dtype=torch.long	,device=_a )
        return inputs_dict






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

        '''simple docstring'''




        A_						:  Tuple          =				OpenAIGPTModelTester(self )
        A_						:  Optional[int]          =				ConfigTester(self	,config_class=_a	,n_embd=37 )






  def        _a							(							self :       Any ):

        '''simple docstring'''




        self.config_tester.run_common_tests()






  def        _a							(							self :       Optional[Any] ):

        '''simple docstring'''




        A_						:  int          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_model(*_a )






  def        _a							(							self :       Tuple ):

        '''simple docstring'''




        A_						:  Dict          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_lm_head_model(*_a )






  def        _a							(							self :       List[Any] ):

        '''simple docstring'''




        A_						:  str          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_double_lm_head_model(*_a )






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

        '''simple docstring'''




        A_						:  List[Any]          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_a )






  @slow
  def        _a							(							self :       List[Any] ):

        '''simple docstring'''




        for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              A_						:  Union[str, Any]          =				OpenAIGPTModel.from_pretrained(_a )
              self.assertIsNotNone(_a )







@require_torch
class 	__lowerCAmelCase		(							unittest.TestCase    ):


  '''simple docstring'''







  @slow
  def        _a							(							self :       List[str] ):

        '''simple docstring'''




        A_						:  Dict          =				OpenAIGPTLMHeadModel.from_pretrained("""openai-gpt""" )
        model.to(_a )
        A_						:  Dict          =				torch.tensor([[481, 4735, 544]]	,dtype=torch.long	,device=_a )  # the president is
        A_						:  Dict          =				[
            481,
            4735,
            544,
            246,
            963,
            870,
            762,
            239,
            244,
            40477,
            244,
            249,
            719,
            881,
            487,
            544,
            240,
            244,
            603,
            481,
        ]  # the president is a very good man. " \n " i\'m sure he is, " said the

        A_						:  int          =				model.generate(_a	,do_sample=_a )
        self.assertListEqual(output_ids[0].tolist()	,_a )
