




import json
import os
import shutil
import warnings
from argparse import ArgumentParser, Namespace
from pathlib import Path
from typing import List

from ..utils import logging
from . import BaseTransformersCLICommand


try:
     from cookiecutter.main import cookiecutter

     UpperCamelCase								=	True
except ImportError:
     UpperCamelCase								=	False

UpperCamelCase								=	logging.get_logger(__name__)  # pylint: disable=invalid-name



def 				_A  (		lowerCAmelCase_	:   Namespace     ):
     """simple docstring"""

     return AddNewModelCommand(args.testing  ,							args.testing_file  ,							path=args.path     )






class 					__lowerCamelCase			(       UpperCamelCase__       ):




    """simple docstring"""

    @staticmethod
    def   a (			SCREAMING_SNAKE_CASE__	:	ArgumentParser  ) ->			int:
         lowerCAmelCase__            =					parser.add_parser("add-new-model"  )
         add_new_model_parser.add_argument("--testing"  ,      action="store_true"  ,      help="If in testing mode."  )
         add_new_model_parser.add_argument("--testing_file"  ,      type=SCREAMING_SNAKE_CASE__  ,      help="Configuration file on which to run."  )
         add_new_model_parser.add_argument(
             "--path"  ,      type=SCREAMING_SNAKE_CASE__  ,      help="Path to cookiecutter. Should only be used for testing purposes."  )
         add_new_model_parser.set_defaults(func=SCREAMING_SNAKE_CASE__  )


    def __init__(			self	:	Tuple  ,      SCREAMING_SNAKE_CASE__	:	bool  ,      SCREAMING_SNAKE_CASE__	:	str  ,      SCREAMING_SNAKE_CASE__	:	Optional[Any]=None  ,      *SCREAMING_SNAKE_CASE__	:	Tuple  ) ->			List[Any]:
         lowerCAmelCase__            =					testing
         lowerCAmelCase__            =					testing_file
         lowerCAmelCase__            =					path


    def   a (			self	:	Union[str, Any]  ) ->			Tuple:
         warnings.warn(
             "The command `transformers-cli add-new-model` is deprecated and will be removed in v5 of Transformers. "
             "It is not actively maintained anymore, so might give a result that won't pass all tests and quality "
             "checks, you should use `transformers-cli add-new-model-like` instead."  )
         if not _has_cookiecutter:
              raise ImportError(
                  "Model creation dependencies are required to use the `add_new_model` command. Install them by running "
                  "the following at the root of your `transformers` clone:\n\n\t$ pip install -e .[modelcreation]\n"  )
         # Ensure that there is no other `cookiecutter-template-xxx` directory in the current working directory
         lowerCAmelCase__            =					[directory for directory in os.listdir() if "cookiecutter-template-" == directory[:22]]
         if len(SCREAMING_SNAKE_CASE__  ) > 0:
              raise ValueError(
                  "Several directories starting with `cookiecutter-template-` in current working directory. "
                  "Please clean your directory by removing all folders starting with `cookiecutter-template-` or "
                  "change your working directory."  )

         lowerCAmelCase__            =					(
             Path(SCREAMING_SNAKE_CASE__  ).parent.parent.parent.parent if self._path is None else Path(self._path  ).parent.parent
         )
         lowerCAmelCase__            =					path_to_transformer_root / "templates" / "adding_a_new_model"

         # Execute cookiecutter
         if not self._testing:
              cookiecutter(str(SCREAMING_SNAKE_CASE__  )  )
         else:
              with open(self._testing_file  ,      "r"  ) as configuration_file:
                   lowerCAmelCase__            =					json.load(SCREAMING_SNAKE_CASE__  )

              cookiecutter(
                  str(path_to_cookiecutter if self._path is None else self._path  )  ,      no_input=SCREAMING_SNAKE_CASE__  ,      extra_context=SCREAMING_SNAKE_CASE__  ,      )

         lowerCAmelCase__            =					[directory for directory in os.listdir() if "cookiecutter-template-" in directory[:22]][0]

         # Retrieve configuration
         with open(directory + "/configuration.json"  ,      "r"  ) as configuration_file:
              lowerCAmelCase__            =					json.load(SCREAMING_SNAKE_CASE__  )

         lowerCAmelCase__            =					configuration["lowercase_modelname"]
         lowerCAmelCase__            =					configuration["generate_tensorflow_pytorch_and_flax"]
         os.remove(f'{directory}/configuration.json'  )

         lowerCAmelCase__            =					"PyTorch" in generate_tensorflow_pytorch_and_flax
         lowerCAmelCase__            =					"TensorFlow" in generate_tensorflow_pytorch_and_flax
         lowerCAmelCase__            =					"Flax" in generate_tensorflow_pytorch_and_flax

         lowerCAmelCase__            =					f'{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}'
         os.makedirs(SCREAMING_SNAKE_CASE__  ,      exist_ok=SCREAMING_SNAKE_CASE__  )
         os.makedirs(f'{path_to_transformer_root}/tests/models/{lowercase_model_name}'  ,      exist_ok=SCREAMING_SNAKE_CASE__  )

         # Tests require submodules as they have parent imports
         with open(f'{path_to_transformer_root}/tests/models/{lowercase_model_name}/__init__.py'  ,      "w"  ):
              pass

         shutil.move(
             f'{directory}/__init__.py'  ,      f'{model_dir}/__init__.py'  ,      )
         shutil.move(
             f'{directory}/configuration_{lowercase_model_name}.py'  ,      f'{model_dir}/configuration_{lowercase_model_name}.py'  ,      )

         def remove_copy_lines(SCREAMING_SNAKE_CASE__	:	Dict  ):
              with open(SCREAMING_SNAKE_CASE__  ,      "r"  ) as f:
                   lowerCAmelCase__            =					f.readlines()
              with open(SCREAMING_SNAKE_CASE__  ,      "w"  ) as f:
                   for line in lines:
                        if "# Copied from transformers." not in line:
                             f.write(SCREAMING_SNAKE_CASE__  )

         if output_pytorch:
              if not self._testing:
                   remove_copy_lines(f'{directory}/modeling_{lowercase_model_name}.py'  )

              shutil.move(
                  f'{directory}/modeling_{lowercase_model_name}.py'  ,      f'{model_dir}/modeling_{lowercase_model_name}.py'  ,      )

              shutil.move(
                  f'{directory}/test_modeling_{lowercase_model_name}.py'  ,      f'{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_{lowercase_model_name}.py'  ,      )
         else:
              os.remove(f'{directory}/modeling_{lowercase_model_name}.py'  )
              os.remove(f'{directory}/test_modeling_{lowercase_model_name}.py'  )

         if output_tensorflow:
              if not self._testing:
                   remove_copy_lines(f'{directory}/modeling_tf_{lowercase_model_name}.py'  )

              shutil.move(
                  f'{directory}/modeling_tf_{lowercase_model_name}.py'  ,      f'{model_dir}/modeling_tf_{lowercase_model_name}.py'  ,      )

              shutil.move(
                  f'{directory}/test_modeling_tf_{lowercase_model_name}.py'  ,      f'{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_tf_{lowercase_model_name}.py'  ,      )
         else:
              os.remove(f'{directory}/modeling_tf_{lowercase_model_name}.py'  )
              os.remove(f'{directory}/test_modeling_tf_{lowercase_model_name}.py'  )

         if output_flax:
              if not self._testing:
                   remove_copy_lines(f'{directory}/modeling_flax_{lowercase_model_name}.py'  )

              shutil.move(
                  f'{directory}/modeling_flax_{lowercase_model_name}.py'  ,      f'{model_dir}/modeling_flax_{lowercase_model_name}.py'  ,      )

              shutil.move(
                  f'{directory}/test_modeling_flax_{lowercase_model_name}.py'  ,      f'{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_flax_{lowercase_model_name}.py'  ,      )
         else:
              os.remove(f'{directory}/modeling_flax_{lowercase_model_name}.py'  )
              os.remove(f'{directory}/test_modeling_flax_{lowercase_model_name}.py'  )

         shutil.move(
             f'{directory}/{lowercase_model_name}.md'  ,      f'{path_to_transformer_root}/docs/source/en/model_doc/{lowercase_model_name}.md'  ,      )

         shutil.move(
             f'{directory}/tokenization_{lowercase_model_name}.py'  ,      f'{model_dir}/tokenization_{lowercase_model_name}.py'  ,      )

         shutil.move(
             f'{directory}/tokenization_fast_{lowercase_model_name}.py'  ,      f'{model_dir}/tokenization_{lowercase_model_name}_fast.py'  ,      )

         from os import fdopen, remove
         from shutil import copymode, move
         from tempfile import mkstemp

         def replace(SCREAMING_SNAKE_CASE__	:	str  ,      SCREAMING_SNAKE_CASE__	:	str  ,      SCREAMING_SNAKE_CASE__	:	List[str]  ):
              # Create temp file
              lowerCAmelCase__      ,						lowerCAmelCase__            =					mkstemp()
              lowerCAmelCase__            =					False
              with fdopen(SCREAMING_SNAKE_CASE__  ,      "w"  ) as new_file:
                   with open(SCREAMING_SNAKE_CASE__  ) as old_file:
                        for line in old_file:
                             new_file.write(SCREAMING_SNAKE_CASE__  )
                             if line_to_copy_below in line:
                                  lowerCAmelCase__            =					True
                                  for line_to_copy in lines_to_copy:
                                       new_file.write(SCREAMING_SNAKE_CASE__  )

              if not line_found:
                   raise ValueError(f'Line {line_to_copy_below} was not found in file.'  )

              # Copy the file permissions from the old file to the new file
              copymode(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  )
              # Remove original file
              remove(SCREAMING_SNAKE_CASE__  )
              # Move new file
              move(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  )

         def skip_units(SCREAMING_SNAKE_CASE__	:	List[Any]  ):
              return (
                  ("generating PyTorch" in line and not output_pytorch)
                  or ("generating TensorFlow" in line and not output_tensorflow)
                  or ("generating Flax" in line and not output_flax)
              )

         def replace_in_files(SCREAMING_SNAKE_CASE__	:	List[Any]  ):
              with open(SCREAMING_SNAKE_CASE__  ) as datafile:
                   lowerCAmelCase__            =					[]
                   lowerCAmelCase__            =					False
                   lowerCAmelCase__            =					False
                   for line in datafile:
                        if "# To replace in: " in line and "##" not in line:
                             lowerCAmelCase__            =					line.split("\""  )[1]
                             lowerCAmelCase__            =					skip_units(SCREAMING_SNAKE_CASE__  )
                        elif "# Below: " in line and "##" not in line:
                             lowerCAmelCase__            =					line.split("\""  )[1]
                             lowerCAmelCase__            =					skip_units(SCREAMING_SNAKE_CASE__  )
                        elif "# End." in line and "##" not in line:
                             if not skip_file and not skip_snippet:
                                  replace(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  )

                             lowerCAmelCase__            =					[]
                        elif "# Replace with" in line and "##" not in line:
                             lowerCAmelCase__            =					[]
                        elif "##" not in line:
                             lines_to_copy.append(SCREAMING_SNAKE_CASE__  )

              remove(SCREAMING_SNAKE_CASE__  )

         replace_in_files(f'{directory}/to_replace_{lowercase_model_name}.py'  )
         os.rmdir(SCREAMING_SNAKE_CASE__  )







"""simple docstring"""
import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
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 OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel







class       a							:



 def __init__(     self				,       _snake_case				,       _snake_case=13				,       _snake_case=7				,       _snake_case=True				,       _snake_case=True				,       _snake_case=False				,       _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_input_mask
  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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  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
  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    				= self.get_config()

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return OpenLlamaConfig(
      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				,       is_decoder=_snake_case				,       initializer_range=self.initializer_range				,       use_stable_embedding=_snake_case				,       )



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







  """simple docstring"""






  lowerCAmelCase    				= OpenLlamaModel(config=_snake_case     )
  model.to(_snake_case     )
  model.eval()
  lowerCAmelCase    				= model(_snake_case				,       attention_mask=_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				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       ):







  """simple docstring"""






  lowerCAmelCase    				= True
  lowerCAmelCase    				= OpenLlamaModel(_snake_case     )
  model.to(_snake_case     )
  model.eval()
  lowerCAmelCase    				= model(
      _snake_case				,       attention_mask=_snake_case				,       encoder_hidden_states=_snake_case				,       encoder_attention_mask=_snake_case				,       )
  lowerCAmelCase    				= model(
      _snake_case				,       attention_mask=_snake_case				,       encoder_hidden_states=_snake_case				,       )
  lowerCAmelCase    				= model(_snake_case				,       attention_mask=_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				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       ):







  """simple docstring"""






  lowerCAmelCase    				= OpenLlamaForCausalLM(config=_snake_case     )
  model.to(_snake_case     )
  model.eval()
  lowerCAmelCase    				= model(_snake_case				,       attention_mask=_snake_case				,       labels=_snake_case     )
  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				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       ):







  """simple docstring"""






  lowerCAmelCase    				= True
  lowerCAmelCase    				= True
  lowerCAmelCase    				= OpenLlamaForCausalLM(config=_snake_case     )
  model.to(_snake_case     )
  model.eval()

  # first forward pass
  lowerCAmelCase    				= model(
      _snake_case				,       attention_mask=_snake_case				,       encoder_hidden_states=_snake_case				,       encoder_attention_mask=_snake_case				,       use_cache=_snake_case				,       )
  lowerCAmelCase    				= outputs.past_key_values

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

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

  lowerCAmelCase    				= model(
      _snake_case				,       attention_mask=_snake_case				,       encoder_hidden_states=_snake_case				,       encoder_attention_mask=_snake_case				,       output_hidden_states=_snake_case				,       )['hidden_states'][0]
  lowerCAmelCase    				= model(
      _snake_case				,       attention_mask=_snake_case				,       encoder_hidden_states=_snake_case				,       encoder_attention_mask=_snake_case				,       past_key_values=_snake_case				,       output_hidden_states=_snake_case				,       )['hidden_states'][0]

  # select random slice
  lowerCAmelCase    				= ids_tensor((1,)				,       output_from_past.shape[-1]     ).item()
  lowerCAmelCase    				= output_from_no_past[:, -3:, random_slice_idx].detach()
  lowerCAmelCase    				= 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(_snake_case				,       _snake_case				,       atol=1E-3     )     )



 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, 'attention_mask': input_mask}
  return config, inputs_dict







@require_torch
class       a							(   a__   , a__   , a__   , unittest.TestCase  ):
 snake_case__             =       (
     (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
 )
 snake_case__             =       (OpenLlamaForCausalLM,) if is_torch_available() else ()
 snake_case__             =       (
     {
         '''feature-extraction''': OpenLlamaModel,
         '''text-classification''': OpenLlamaForSequenceClassification,
         '''text-generation''': OpenLlamaForCausalLM,
         '''zero-shot''': OpenLlamaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 snake_case__             =       False
 snake_case__             =       False



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= OpenLlamaModelTester(self     )
  lowerCAmelCase    				= ConfigTester(self				,       config_class=_snake_case				,       hidden_size=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_model(*_snake_case     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  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(*_snake_case     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase				,lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs_for_common()
  lowerCAmelCase    				= 3
  lowerCAmelCase    				= input_dict['input_ids']
  lowerCAmelCase    				= input_ids.ne(1     ).to(_snake_case     )
  lowerCAmelCase    				= ids_tensor([self.model_tester.batch_size]				,       self.model_tester.type_sequence_label_size     )
  lowerCAmelCase    				= OpenLlamaForSequenceClassification(_snake_case     )
  model.to(_snake_case     )
  model.eval()
  lowerCAmelCase    				= model(_snake_case				,       attention_mask=_snake_case				,       labels=_snake_case     )
  self.assertEqual(result.logits.shape				,       (self.model_tester.batch_size, self.model_tester.num_labels)     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase				,lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs_for_common()
  lowerCAmelCase    				= 3
  lowerCAmelCase    				= 'single_label_classification'
  lowerCAmelCase    				= input_dict['input_ids']
  lowerCAmelCase    				= input_ids.ne(1     ).to(_snake_case     )
  lowerCAmelCase    				= ids_tensor([self.model_tester.batch_size]				,       self.model_tester.type_sequence_label_size     )
  lowerCAmelCase    				= OpenLlamaForSequenceClassification(_snake_case     )
  model.to(_snake_case     )
  model.eval()
  lowerCAmelCase    				= model(_snake_case				,       attention_mask=_snake_case				,       labels=_snake_case     )
  self.assertEqual(result.logits.shape				,       (self.model_tester.batch_size, self.model_tester.num_labels)     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase				,lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs_for_common()
  lowerCAmelCase    				= 3
  lowerCAmelCase    				= 'multi_label_classification'
  lowerCAmelCase    				= input_dict['input_ids']
  lowerCAmelCase    				= input_ids.ne(1     ).to(_snake_case     )
  lowerCAmelCase    				= ids_tensor(
      [self.model_tester.batch_size, config.num_labels]				,       self.model_tester.type_sequence_label_size     ).to(torch.float     )
  lowerCAmelCase    				= OpenLlamaForSequenceClassification(_snake_case     )
  model.to(_snake_case     )
  model.eval()
  lowerCAmelCase    				= model(_snake_case				,       attention_mask=_snake_case				,       labels=_snake_case     )
  self.assertEqual(result.logits.shape				,       (self.model_tester.batch_size, self.model_tester.num_labels)     )



 @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test'     )
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  pass



 @parameterized.expand([('linear',), ('dynamic',)]     )
 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase				,lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs_for_common()
  lowerCAmelCase    				= ids_tensor([1, 10]				,       config.vocab_size     )
  lowerCAmelCase    				= ids_tensor([1, int(config.max_position_embeddings * 1.5     )]				,       config.vocab_size     )

  set_seed(42     )  # Fixed seed at init time so the two models get the same random weights
  lowerCAmelCase    				= OpenLlamaModel(_snake_case     )
  original_model.to(_snake_case     )
  original_model.eval()
  lowerCAmelCase    				= original_model(_snake_case     ).last_hidden_state
  lowerCAmelCase    				= original_model(_snake_case     ).last_hidden_state

  set_seed(42     )  # Fixed seed at init time so the two models get the same random weights
  lowerCAmelCase    				= {'type': scaling_type, 'factor': 10.0}
  lowerCAmelCase    				= OpenLlamaModel(_snake_case     )
  scaled_model.to(_snake_case     )
  scaled_model.eval()
  lowerCAmelCase    				= scaled_model(_snake_case     ).last_hidden_state
  lowerCAmelCase    				= scaled_model(_snake_case     ).last_hidden_state

  # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
  # maximum sequence length, so the outputs for the short input should match.
  if scaling_type == "dynamic":
   self.assertTrue(torch.allclose(_snake_case				,       _snake_case				,       atol=1E-5     )     )
  else:
   self.assertFalse(torch.allclose(_snake_case				,       _snake_case				,       atol=1E-5     )     )

  # The output should be different for long inputs
  self.assertFalse(torch.allclose(_snake_case				,       _snake_case				,       atol=1E-5     )     )





