

import argparse
import json
import os
import re
from collections import OrderedDict
from os.path import basename, dirname

import fairseq
import torch
from fairseq import hub_utils
from fairseq.data.dictionary import Dictionary

from transformers import FSMTConfig, FSMTForConditionalGeneration
from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES
from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE
from transformers.utils import WEIGHTS_NAME, logging


logging.set_verbosity_warning()

__UpperCAmelCase						=					2

# based on the results of a search on a range of `num_beams`, `length_penalty` and `early_stopping`
# values against wmt19 test data to obtain the best BLEU scores, we will use the following defaults:
#
# * `num_beams`: 5 (higher scores better, but requires more memory/is slower, can be adjusted by users)
# * `early_stopping`: `False` consistently scored better
# * `length_penalty` varied, so will assign the best one depending on the model
__UpperCAmelCase						=					{
    # fairseq:
    '''wmt19-ru-en''': {'''length_penalty''': 1.1},
    '''wmt19-en-ru''': {'''length_penalty''': 1.15},
    '''wmt19-en-de''': {'''length_penalty''': 1.0},
    '''wmt19-de-en''': {'''length_penalty''': 1.1},
    # allenai:
    '''wmt16-en-de-dist-12-1''': {'''length_penalty''': 0.6},
    '''wmt16-en-de-dist-6-1''': {'''length_penalty''': 0.6},
    '''wmt16-en-de-12-1''': {'''length_penalty''': 0.8},
    '''wmt19-de-en-6-6-base''': {'''length_penalty''': 0.6},
    '''wmt19-de-en-6-6-big''': {'''length_penalty''': 0.6},
}

# this remaps the different models to their organization names
__UpperCAmelCase						=					{}
for m in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]:
   __UpperCAmelCase						=					'''facebook'''
for m in [
    "wmt16-en-de-dist-12-1",
    "wmt16-en-de-dist-6-1",
    "wmt16-en-de-12-1",
    "wmt19-de-en-6-6-base",
    "wmt19-de-en-6-6-big",
]:
   __UpperCAmelCase						=					'''allenai'''





def       snake_case_ (__A	:		Union[str, Any]	)     ->      List[str]:
   # (1) remove word breaking symbol, (2) add word ending symbol where the word is not broken up,
   # e.g.: d = {'le@@': 5, 'tt@@': 6, 'er': 7} => {'le': 5, 'tt': 6, 'er</w>': 7}
   __lowerCAmelCase    :     Optional[Any]          =		dict((re.sub(r"""@@$"""   ,  """"""   ,  _UpperCAmelCase	), v) if k.endswith("""@@"""	) else (re.sub(r"""$"""   ,  """</w>"""   ,  _UpperCAmelCase	), v) for k, v in d.items()	)
   __lowerCAmelCase    :     List[str]          =		"""<s> <pad> </s> <unk>""".split()
   # restore the special tokens
   for k in keep_keys:
      del da[f'''{k}</w>''']
      __lowerCAmelCase    :     Any          =		d[k]  # restore
   return da





def       snake_case_ (__A	:		str   ,  __A	:		Any	)     ->      str:
   # prep
   assert os.path.exists(_UpperCAmelCase	)
   os.makedirs(_UpperCAmelCase   ,  exist_ok=_UpperCAmelCase	)
   print(f'''Writing results to {pytorch_dump_folder_path}'''	)

   # handle various types of models

   __lowerCAmelCase    :     Union[str, Any]          =		basename(_UpperCAmelCase	)
   __lowerCAmelCase    :     Tuple          =		dirname(_UpperCAmelCase	)

   __lowerCAmelCase    :     Union[str, Any]          =		fairseq.model_parallel.models.transformer.ModelParallelTransformerModel
   __lowerCAmelCase    :     Optional[Any]          =		cls.hub_models()
   __lowerCAmelCase    :     Any          =		{"""bpe""": """fastbpe""", """tokenizer""": """moses"""}
   __lowerCAmelCase    :     Tuple          =		"""."""
   # note: since the model dump is old, fairseq has upgraded its model some
   # time later, and it does a whole lot of rewrites and splits on the saved
   # weights, therefore we can't use torch.load() directly on the model file.
   # see: upgrade_state_dict(state_dict) in fairseq_model.py
   print(f'''using checkpoint {checkpoint_file}'''	)
   __lowerCAmelCase    :     Optional[Any]          =		hub_utils.from_pretrained(
       _UpperCAmelCase   ,  _UpperCAmelCase   ,  _UpperCAmelCase   ,  archive_map=_UpperCAmelCase   ,  **_UpperCAmelCase	)

   __lowerCAmelCase    :     Optional[Any]          =		vars(chkpt["""args"""]["""model"""]	)

   __lowerCAmelCase    :     Optional[Any]          =		args["""source_lang"""]
   __lowerCAmelCase    :     List[Any]          =		args["""target_lang"""]

   __lowerCAmelCase    :     str          =		dirname(_UpperCAmelCase	)
   __lowerCAmelCase    :     int          =		basename(_UpperCAmelCase	)

   # dicts
   __lowerCAmelCase    :     Tuple          =		os.path.join(_UpperCAmelCase   ,  f'''dict.{src_lang}.txt'''	)
   __lowerCAmelCase    :     int          =		os.path.join(_UpperCAmelCase   ,  f'''dict.{tgt_lang}.txt'''	)

   __lowerCAmelCase    :     Union[str, Any]          =		Dictionary.load(_UpperCAmelCase	)
   __lowerCAmelCase    :     Tuple          =		rewrite_dict_keys(src_dict.indices	)
   __lowerCAmelCase    :     Optional[Any]          =		len(_UpperCAmelCase	)
   __lowerCAmelCase    :     List[str]          =		os.path.join(_UpperCAmelCase   ,  """vocab-src.json"""	)
   print(f'''Generating {src_vocab_file} of {src_vocab_size} of {src_lang} records'''	)
   with open(_UpperCAmelCase   ,  """w"""   ,  encoding="""utf-8"""	) as f:
      f.write(json.dumps(_UpperCAmelCase   ,  ensure_ascii=_UpperCAmelCase   ,  indent=_UpperCAmelCase	)	)

   # detect whether this is a do_lower_case situation, which can be derived by checking whether we
   # have at least one uppercase letter in the source vocab
   __lowerCAmelCase    :     int          =		True
   for k in src_vocab.keys():
      if not k.islower():
         __lowerCAmelCase    :     List[Any]          =		False
         break

   __lowerCAmelCase    :     Optional[int]          =		Dictionary.load(_UpperCAmelCase	)
   __lowerCAmelCase    :     List[Any]          =		rewrite_dict_keys(tgt_dict.indices	)
   __lowerCAmelCase    :     List[Any]          =		len(_UpperCAmelCase	)
   __lowerCAmelCase    :     int          =		os.path.join(_UpperCAmelCase   ,  """vocab-tgt.json"""	)
   print(f'''Generating {tgt_vocab_file} of {tgt_vocab_size} of {tgt_lang} records'''	)
   with open(_UpperCAmelCase   ,  """w"""   ,  encoding="""utf-8"""	) as f:
      f.write(json.dumps(_UpperCAmelCase   ,  ensure_ascii=_UpperCAmelCase   ,  indent=_UpperCAmelCase	)	)

   # merges_file (bpecodes)
   __lowerCAmelCase    :     str          =		os.path.join(_UpperCAmelCase   ,  VOCAB_FILES_NAMES["""merges_file"""]	)
   for fn in ["bpecodes", "code"]:  # older fairseq called the merges file "code"
      __lowerCAmelCase    :     str          =		os.path.join(_UpperCAmelCase   ,  _UpperCAmelCase	)
      if os.path.exists(_UpperCAmelCase	):
         break
   with open(_UpperCAmelCase   ,  encoding="""utf-8"""	) as fin:
      __lowerCAmelCase    :     Optional[Any]          =		fin.read()
   __lowerCAmelCase    :     Optional[Any]          =		re.sub(r""" \d+$"""   ,  """"""   ,  _UpperCAmelCase   ,  0   ,  re.M	)  # remove frequency number
   print(f'''Generating {merges_file}'''	)
   with open(_UpperCAmelCase   ,  """w"""   ,  encoding="""utf-8"""	) as fout:
      fout.write(_UpperCAmelCase	)

   # model config
   __lowerCAmelCase    :     List[str]          =		os.path.join(_UpperCAmelCase   ,  """config.json"""	)

   # validate bpe/tokenizer config, as currently it's hardcoded to moses+fastbpe -
   # may have to modify the tokenizer if a different type is used by a future model
   assert args["bpe"] == "fastbpe", f'''need to extend tokenizer to support bpe={args['bpe']}'''
   assert args["tokenizer"] == "moses", f'''need to extend tokenizer to support bpe={args['tokenizer']}'''

   __lowerCAmelCase    :     List[Any]          =		{
       """architectures""": ["""FSMTForConditionalGeneration"""],
       """model_type""": """fsmt""",
       """activation_dropout""": args["""activation_dropout"""],
       """activation_function""": """relu""",
       """attention_dropout""": args["""attention_dropout"""],
       """d_model""": args["""decoder_embed_dim"""],
       """dropout""": args["""dropout"""],
       """init_std""": 0.02,
       """max_position_embeddings""": args["""max_source_positions"""],
       """num_hidden_layers""": args["""encoder_layers"""],
       """src_vocab_size""": src_vocab_size,
       """tgt_vocab_size""": tgt_vocab_size,
       """langs""": [src_lang, tgt_lang],
       """encoder_attention_heads""": args["""encoder_attention_heads"""],
       """encoder_ffn_dim""": args["""encoder_ffn_embed_dim"""],
       """encoder_layerdrop""": args["""encoder_layerdrop"""],
       """encoder_layers""": args["""encoder_layers"""],
       """decoder_attention_heads""": args["""decoder_attention_heads"""],
       """decoder_ffn_dim""": args["""decoder_ffn_embed_dim"""],
       """decoder_layerdrop""": args["""decoder_layerdrop"""],
       """decoder_layers""": args["""decoder_layers"""],
       """bos_token_id""": 0,
       """pad_token_id""": 1,
       """eos_token_id""": 2,
       """is_encoder_decoder""": True,
       """scale_embedding""": not args["""no_scale_embedding"""],
       """tie_word_embeddings""": args["""share_all_embeddings"""],
   }

   # good hparam defaults to start with
   __lowerCAmelCase    :     Tuple          =		5
   __lowerCAmelCase    :     Dict          =		False
   if model_dir in best_score_hparams and "length_penalty" in best_score_hparams[model_dir]:
      __lowerCAmelCase    :     List[str]          =		best_score_hparams[model_dir]["""length_penalty"""]
   else:
      __lowerCAmelCase    :     List[Any]          =		1.0

   print(f'''Generating {fsmt_model_config_file}'''	)
   with open(_UpperCAmelCase   ,  """w"""   ,  encoding="""utf-8"""	) as f:
      f.write(json.dumps(_UpperCAmelCase   ,  ensure_ascii=_UpperCAmelCase   ,  indent=_UpperCAmelCase	)	)

   # tokenizer config
   __lowerCAmelCase    :     Union[str, Any]          =		os.path.join(_UpperCAmelCase   ,  _UpperCAmelCase	)

   __lowerCAmelCase    :     Tuple          =		{
       """langs""": [src_lang, tgt_lang],
       """model_max_length""": 1_0_2_4,
       """do_lower_case""": do_lower_case,
   }

   print(f'''Generating {fsmt_tokenizer_config_file}'''	)
   with open(_UpperCAmelCase   ,  """w"""   ,  encoding="""utf-8"""	) as f:
      f.write(json.dumps(_UpperCAmelCase   ,  ensure_ascii=_UpperCAmelCase   ,  indent=_UpperCAmelCase	)	)

   # model
   __lowerCAmelCase    :     Union[str, Any]          =		chkpt["""models"""][0]
   __lowerCAmelCase    :     Optional[Any]          =		model.state_dict()

   # rename keys to start with 'model.'
   __lowerCAmelCase    :     Optional[Any]          =		OrderedDict(("""model.""" + k, v) for k, v in model_state_dict.items()	)

   # remove unneeded keys
   __lowerCAmelCase    :     Union[str, Any]          =		[
       """model.model""",
       """model.encoder.version""",
       """model.decoder.version""",
       """model.encoder_embed_tokens.weight""",
       """model.decoder_embed_tokens.weight""",
       """model.encoder.embed_positions._float_tensor""",
       """model.decoder.embed_positions._float_tensor""",
   ]
   for k in ignore_keys:
      model_state_dict.pop(_UpperCAmelCase   ,  _UpperCAmelCase	)

   __lowerCAmelCase    :     Union[str, Any]          =		FSMTConfig.from_pretrained(_UpperCAmelCase	)
   __lowerCAmelCase    :     List[Any]          =		FSMTForConditionalGeneration(_UpperCAmelCase	)

   # check that it loads ok
   model_new.load_state_dict(_UpperCAmelCase   ,  strict=_UpperCAmelCase	)

   # save
   __lowerCAmelCase    :     Dict          =		os.path.join(_UpperCAmelCase   ,  _UpperCAmelCase	)
   print(f'''Generating {pytorch_weights_dump_path}'''	)
   torch.save(_UpperCAmelCase   ,  _UpperCAmelCase	)

   print("""Conversion is done!"""	)
   print("""\nLast step is to upload the files to s3"""	)
   print(f'''cd {data_root}'''	)
   print(f'''transformers-cli upload {model_dir}'''	)


if __name__ == "__main__":
   __UpperCAmelCase						=					argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--fsmt_checkpoint_path""",
       default=None,
       type=str,
       required=True,
       help=(
           """Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts,"""
           """ bpecodes, etc."""
       ),
   )
   parser.add_argument(
       """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
   )
   __UpperCAmelCase						=					parser.parse_args()
   convert_fsmt_checkpoint_to_pytorch(args.fsmt_checkpoint_path, args.pytorch_dump_folder_path)









"""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     )





