





"""simple docstring"""
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__UpperCamelCase     :						Union[str, Any]						       =  logging.get_logger(__name__)

__UpperCamelCase     :						List[str]						       =  {
    '''Helsinki-NLP/opus-mt-en-de''': '''https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json''',
    # See all Marian models at https://huggingface.co/models?filter=marian
}







class       a							(   a__  ):
 snake_case__             =       '''marian'''
 snake_case__             =       ['''past_key_values''']
 snake_case__             =       {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}



 def __init__(     self				,       _snake_case=5_81_01				,       _snake_case=None				,       _snake_case=10_24				,       _snake_case=12				,       _snake_case=40_96				,       _snake_case=16				,       _snake_case=12				,       _snake_case=40_96				,       _snake_case=16				,       _snake_case=0.0				,       _snake_case=0.0				,       _snake_case=True				,       _snake_case=True				,       _snake_case="gelu"				,       _snake_case=10_24				,       _snake_case=0.1				,       _snake_case=0.0				,       _snake_case=0.0				,       _snake_case=0.02				,       _snake_case=5_81_00				,       _snake_case=False				,       _snake_case=5_81_00				,       _snake_case=0				,       _snake_case=0				,       _snake_case=True				,       **_snake_case				,       ):







  """simple docstring"""






  lowerCAmelCase    				= vocab_size
  lowerCAmelCase    				= decoder_vocab_size or vocab_size
  lowerCAmelCase    				= max_position_embeddings
  lowerCAmelCase    				= d_model
  lowerCAmelCase    				= encoder_ffn_dim
  lowerCAmelCase    				= encoder_layers
  lowerCAmelCase    				= encoder_attention_heads
  lowerCAmelCase    				= decoder_ffn_dim
  lowerCAmelCase    				= decoder_layers
  lowerCAmelCase    				= decoder_attention_heads
  lowerCAmelCase    				= dropout
  lowerCAmelCase    				= attention_dropout
  lowerCAmelCase    				= activation_dropout
  lowerCAmelCase    				= activation_function
  lowerCAmelCase    				= init_std
  lowerCAmelCase    				= encoder_layerdrop
  lowerCAmelCase    				= decoder_layerdrop
  lowerCAmelCase    				= use_cache
  lowerCAmelCase    				= encoder_layers
  lowerCAmelCase    				= scale_embedding  # scale factor will be sqrt(d_model) if True
  lowerCAmelCase    				= share_encoder_decoder_embeddings
  super().__init__(
      pad_token_id=_snake_case				,       eos_token_id=_snake_case				,       is_encoder_decoder=_snake_case				,       decoder_start_token_id=_snake_case				,       forced_eos_token_id=_snake_case				,       **_snake_case				,       )







class       a							(   a__  ):



 @property
 # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  if self.task in ["default", "seq2seq-lm"]:
   lowerCAmelCase    				= OrderedDict(
       [
           ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
           ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
       ]     )

   if self.use_past:
    lowerCAmelCase    				= {0: 'batch'}
    lowerCAmelCase    				= {0: 'batch', 1: 'past_decoder_sequence + sequence'}
   else:
    lowerCAmelCase    				= {0: 'batch', 1: 'decoder_sequence'}
    lowerCAmelCase    				= {0: 'batch', 1: 'decoder_sequence'}

   if self.use_past:
    self.fill_with_past_key_values_(_snake_case				,       direction='inputs'     )
  elif self.task == "causal-lm":
   # TODO: figure this case out.
   lowerCAmelCase    				= OrderedDict(
       [
           ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
           ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
       ]     )
   if self.use_past:
    lowerCAmelCase				,lowerCAmelCase    				= self.num_layers
    for i in range(_snake_case     ):
     lowerCAmelCase    				= {0: 'batch', 2: 'past_sequence + sequence'}
     lowerCAmelCase    				= {0: 'batch', 2: 'past_sequence + sequence'}
  else:
   lowerCAmelCase    				= OrderedDict(
       [
           ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
           ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
           ('decoder_input_ids', {0: 'batch', 1: 'decoder_sequence'}),
           ('decoder_attention_mask', {0: 'batch', 1: 'decoder_sequence'}),
       ]     )

  return common_inputs



 @property
 # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  if self.task in ["default", "seq2seq-lm"]:
   lowerCAmelCase    				= super().outputs
  else:
   lowerCAmelCase    				= super(_snake_case				,       self     ).outputs
   if self.use_past:
    lowerCAmelCase				,lowerCAmelCase    				= self.num_layers
    for i in range(_snake_case     ):
     lowerCAmelCase    				= {0: 'batch', 2: 'past_sequence + sequence'}
     lowerCAmelCase    				= {0: 'batch', 2: 'past_sequence + sequence'}
  return common_outputs



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case = -1				,       _snake_case = -1				,       _snake_case = False				,       _snake_case = None				,       ):







  """simple docstring"""






  lowerCAmelCase    				= self._generate_dummy_inputs_for_encoder_and_decoder(
      _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case     )

  # Generate decoder inputs
  lowerCAmelCase    				= seq_length if not self.use_past else 1
  lowerCAmelCase    				= self._generate_dummy_inputs_for_encoder_and_decoder(
      _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case     )
  lowerCAmelCase    				= {F'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
  lowerCAmelCase    				= dict(**_snake_case				,       **_snake_case     )

  if self.use_past:
   if not is_torch_available():
    raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'     )
   else:
    import torch
   lowerCAmelCase				,lowerCAmelCase    				= common_inputs['input_ids'].shape
   lowerCAmelCase    				= common_inputs['decoder_input_ids'].shape[1]
   lowerCAmelCase				,lowerCAmelCase    				= self.num_attention_heads
   lowerCAmelCase    				= (
       batch,
       num_encoder_attention_heads,
       encoder_seq_length,
       self._config.hidden_size // num_encoder_attention_heads,
   )
   lowerCAmelCase    				= decoder_seq_length + 3
   lowerCAmelCase    				= (
       batch,
       num_decoder_attention_heads,
       decoder_past_length,
       self._config.hidden_size // num_decoder_attention_heads,
   )

   lowerCAmelCase    				= torch.cat(
       [common_inputs['decoder_attention_mask'], torch.ones(_snake_case				,       _snake_case     )]				,       dim=1     )

   lowerCAmelCase    				= []
   # If the number of encoder and decoder layers are present in the model configuration, both are considered
   lowerCAmelCase				,lowerCAmelCase    				= self.num_layers
   lowerCAmelCase    				= min(_snake_case				,       _snake_case     )
   lowerCAmelCase    				= max(_snake_case				,       _snake_case     ) - min_num_layers
   lowerCAmelCase    				= 'encoder' if num_encoder_layers > num_decoder_layers else 'decoder'

   for _ in range(_snake_case     ):
    common_inputs["past_key_values"].append(
        (
            torch.zeros(_snake_case     ),
            torch.zeros(_snake_case     ),
            torch.zeros(_snake_case     ),
            torch.zeros(_snake_case     ),
        )     )
   # TODO: test this.
   lowerCAmelCase    				= encoder_shape if remaining_side_name == 'encoder' else decoder_shape
   for _ in range(_snake_case				,       _snake_case     ):
    common_inputs["past_key_values"].append((torch.zeros(_snake_case     ), torch.zeros(_snake_case     ))     )
  return common_inputs



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case = -1				,       _snake_case = -1				,       _snake_case = False				,       _snake_case = None				,       ):







  """simple docstring"""






  lowerCAmelCase    				= self._generate_dummy_inputs_for_encoder_and_decoder(
      _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case     )

  if self.use_past:
   if not is_torch_available():
    raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'     )
   else:
    import torch
   lowerCAmelCase				,lowerCAmelCase    				= common_inputs['input_ids'].shape
   # Not using the same length for past_key_values
   lowerCAmelCase    				= seqlen + 2
   lowerCAmelCase				,lowerCAmelCase    				= self.num_layers
   lowerCAmelCase				,lowerCAmelCase    				= self.num_attention_heads
   lowerCAmelCase    				= (
       batch,
       num_encoder_attention_heads,
       past_key_values_length,
       self._config.hidden_size // num_encoder_attention_heads,
   )

   lowerCAmelCase    				= common_inputs['attention_mask'].dtype
   lowerCAmelCase    				= torch.cat(
       [common_inputs['attention_mask'], torch.ones(_snake_case				,       _snake_case				,       dtype=_snake_case     )]				,       dim=1     )
   lowerCAmelCase    				= [
       (torch.zeros(_snake_case     ), torch.zeros(_snake_case     )) for _ in range(_snake_case     )
   ]
  return common_inputs



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case = -1				,       _snake_case = -1				,       _snake_case = False				,       _snake_case = None				,       ):







  """simple docstring"""






  lowerCAmelCase    				= compute_effective_axis_dimension(
      _snake_case				,       fixed_dimension=OnnxConfig.default_fixed_batch				,       num_token_to_add=0     )

  # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
  lowerCAmelCase    				= tokenizer.num_special_tokens_to_add(_snake_case     )
  lowerCAmelCase    				= compute_effective_axis_dimension(
      _snake_case				,       fixed_dimension=OnnxConfig.default_fixed_sequence				,       num_token_to_add=_snake_case     )

  # Generate dummy inputs according to compute batch and sequence
  lowerCAmelCase    				= [' '.join([tokenizer.unk_token]     ) * seq_length] * batch_size
  lowerCAmelCase    				= dict(tokenizer(_snake_case				,       return_tensors=_snake_case     )     )
  return common_inputs



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case = -1				,       _snake_case = -1				,       _snake_case = False				,       _snake_case = None				,       ):







  """simple docstring"""






  if self.task in ["default", "seq2seq-lm"]:
   lowerCAmelCase    				= self._generate_dummy_inputs_for_default_and_seqaseq_lm(
       _snake_case				,       batch_size=_snake_case				,       seq_length=_snake_case				,       is_pair=_snake_case				,       framework=_snake_case     )

  else:
   lowerCAmelCase    				= self._generate_dummy_inputs_for_causal_lm(
       _snake_case				,       batch_size=_snake_case				,       seq_length=_snake_case				,       is_pair=_snake_case				,       framework=_snake_case     )

  return common_inputs



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case     ):







  """simple docstring"""






  if self.task in ["default", "seq2seq-lm"]:
   lowerCAmelCase    				= super()._flatten_past_key_values_(_snake_case				,       _snake_case				,       _snake_case				,       _snake_case     )
  else:
   lowerCAmelCase    				= super(_snake_case				,       self     )._flatten_past_key_values_(
       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case     )



 @property
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return 1E-4












"""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       a							:



 def __init__(     self				,       _snake_case				,       _snake_case=13				,       _snake_case=7				,       _snake_case=True				,       _snake_case=True				,       _snake_case=True				,       _snake_case=99				,       _snake_case=32				,       _snake_case=5				,       _snake_case=4				,       _snake_case=37				,       _snake_case="gelu"				,       _snake_case=0.1				,       _snake_case=0.1				,       _snake_case=5_12				,       _snake_case=16				,       _snake_case=2				,       _snake_case=0.02				,       _snake_case=3				,       _snake_case=4				,       _snake_case=None				,       ):







  """simple docstring"""






  lowerCAmelCase    				= parent
  lowerCAmelCase    				= batch_size
  lowerCAmelCase    				= seq_length
  lowerCAmelCase    				= is_training
  lowerCAmelCase    				= use_token_type_ids
  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
  lowerCAmelCase    				= self.vocab_size - 1



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size     )

  lowerCAmelCase    				= None
  if self.use_token_type_ids:
   lowerCAmelCase    				= ids_tensor([self.batch_size, self.seq_length]				,       self.type_vocab_size     )

  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    				= 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				,       )

  lowerCAmelCase    				= 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    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       *_snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= OpenAIGPTModel(config=_snake_case     )
  model.to(_snake_case     )
  model.eval()

  lowerCAmelCase    				= model(_snake_case				,       token_type_ids=_snake_case				,       head_mask=_snake_case     )
  lowerCAmelCase    				= model(_snake_case				,       token_type_ids=_snake_case     )
  lowerCAmelCase    				= model(_snake_case     )

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



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       *_snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= OpenAIGPTLMHeadModel(_snake_case     )
  model.to(_snake_case     )
  model.eval()

  lowerCAmelCase    				= model(_snake_case				,       token_type_ids=_snake_case				,       labels=_snake_case     )
  self.parent.assertEqual(result.loss.shape				,       ()     )
  self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)     )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       *_snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= OpenAIGPTDoubleHeadsModel(_snake_case     )
  model.to(_snake_case     )
  model.eval()

  lowerCAmelCase    				= model(_snake_case				,       token_type_ids=_snake_case				,       labels=_snake_case     )
  self.parent.assertEqual(result.loss.shape				,       ()     )
  self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)     )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       *_snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= self.num_labels
  lowerCAmelCase    				= OpenAIGPTForSequenceClassification(_snake_case     )
  model.to(_snake_case     )
  model.eval()

  lowerCAmelCase    				= ids_tensor([self.batch_size]				,       self.type_sequence_label_size     )
  lowerCAmelCase    				= model(_snake_case				,       token_type_ids=_snake_case				,       labels=_snake_case     )
  self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.prepare_config_and_inputs()
  (
      (
      lowerCAmelCase
  )				,(
      lowerCAmelCase
  )				,(
      lowerCAmelCase
  )				,(
      lowerCAmelCase
  )				,(
      lowerCAmelCase
  )				,(
      lowerCAmelCase
  )				,(
      lowerCAmelCase
  )				,
  )    				= config_and_inputs
  lowerCAmelCase    				= {
      'input_ids': input_ids,
      'token_type_ids': token_type_ids,
      'head_mask': head_mask,
  }

  return config, inputs_dict







@require_torch
class       a							(   a__   , a__   , a__   , unittest.TestCase  ):
 snake_case__             =       (
     (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
     if is_torch_available()
     else ()
 )
 snake_case__             =       (
     (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
 )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
 snake_case__             =       (
     {
         '''feature-extraction''': OpenAIGPTModel,
         '''text-classification''': OpenAIGPTForSequenceClassification,
         '''text-generation''': OpenAIGPTLMHeadModel,
         '''zero-shot''': OpenAIGPTForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case     ):







  """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    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case=False     ):







  """simple docstring"""






  lowerCAmelCase    				= super()._prepare_for_class(_snake_case				,       _snake_case				,       return_labels=_snake_case     )

  if return_labels:
   if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
    lowerCAmelCase    				= torch.zeros(
        (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)				,       dtype=torch.long				,       device=_snake_case				,       )
    lowerCAmelCase    				= inputs_dict['labels']
    lowerCAmelCase    				= inputs_dict['labels']
    lowerCAmelCase    				= torch.zeros(
        (self.model_tester.batch_size, self.model_tester.num_choices)				,       dtype=torch.long				,       device=_snake_case				,       )
    lowerCAmelCase    				= torch.zeros(
        self.model_tester.batch_size				,       dtype=torch.long				,       device=_snake_case     )
  return inputs_dict



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= OpenAIGPTModelTester(self     )
  lowerCAmelCase    				= ConfigTester(self				,       config_class=_snake_case				,       n_embd=37     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  self.config_tester.run_common_tests()



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_openai_gpt_model(*_snake_case     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_lm_head_model(*_snake_case     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_double_lm_head_model(*_snake_case     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_snake_case     )



 @slow
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
   lowerCAmelCase    				= OpenAIGPTModel.from_pretrained(_snake_case     )
   self.assertIsNotNone(_snake_case     )







@require_torch
class       a							(   unittest.TestCase  ):



 @slow
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= OpenAIGPTLMHeadModel.from_pretrained('openai-gpt'     )
  model.to(_snake_case     )
  lowerCAmelCase    				= torch.tensor([[4_81, 47_35, 5_44]]				,       dtype=torch.long				,       device=_snake_case     )  # the president is
  lowerCAmelCase    				= [
      4_81,
      47_35,
      5_44,
      2_46,
      9_63,
      8_70,
      7_62,
      2_39,
      2_44,
      4_04_77,
      2_44,
      2_49,
      7_19,
      8_81,
      4_87,
      5_44,
      2_40,
      2_44,
      6_03,
      4_81,
  ]  # the president is a very good man. " \n " i\'m sure he is, " said the

  lowerCAmelCase    				= model.generate(_snake_case				,       do_sample=_snake_case     )
  self.assertListEqual(output_ids[0].tolist()				,       _snake_case     )





