






from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
 import numpy as np
 import tensorflow as tf

 from transformers import (
     TF_MODEL_FOR_CAUSAL_LM_MAPPING,
     TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_MASKED_LM_MAPPING,
     TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
     TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
     TF_MODEL_FOR_PRETRAINING_MAPPING,
     TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     TFSharedEmbeddings,
 )

 if _tf_gpu_memory_limit is not None:
  __snake_case							      =						tf.config.list_physical_devices("""GPU""")
  for gpu in gpus:
   # Restrict TensorFlow to only allocate x GB of memory on the GPUs
   try:
    tf.config.set_logical_device_configuration(
        gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
    )
    __snake_case							      =						tf.config.list_logical_devices("""GPU""")
    print("""Logical GPUs""", logical_gpus)
   except RuntimeError as e:
    # Virtual devices must be set before GPUs have been initialized
    print(e)







@require_tf
class     UpperCAmelCase_		:



      """simple docstring"""
      UpperCamelCase_       :      List[str]     =None
      UpperCamelCase_       :      str     =()
      UpperCamelCase_       :      Optional[Any]     =()
      UpperCamelCase_       :      int     =True
      UpperCamelCase_       :      Tuple     =True
      UpperCamelCase_       :      int     =True
      UpperCamelCase_       :      int     =False
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_=False				)       ->   dict:
          UpperCamelCase :Any										=     copy.deepcopy(SCREAMING_SNAKE_CASE_				)

          if model_class in get_values(SCREAMING_SNAKE_CASE_				):
              UpperCamelCase :List[str]										=     {
                  k: tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_					,       1				)					,       (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)				)
                  if isinstance(SCREAMING_SNAKE_CASE_					,       tf.Tensor				) and v.ndim > 0
                  else v
                  for k, v in inputs_dict.items()
              }

          if return_labels:
              if model_class in get_values(SCREAMING_SNAKE_CASE_				):
                  UpperCamelCase :Any										=     tf.ones(self.model_tester.batch_size					,       dtype=tf.intaa				)
              elif model_class in get_values(SCREAMING_SNAKE_CASE_				):
                  UpperCamelCase :Union[str, Any]										=     tf.zeros(self.model_tester.batch_size					,       dtype=tf.intaa				)
                  UpperCamelCase :int										=     tf.zeros(self.model_tester.batch_size					,       dtype=tf.intaa				)
              elif model_class in [
                  *get_values(SCREAMING_SNAKE_CASE_				),
                  *get_values(SCREAMING_SNAKE_CASE_				),
              ]:
                  UpperCamelCase :Any										=     tf.zeros(self.model_tester.batch_size					,       dtype=tf.intaa				)
              elif model_class in get_values(SCREAMING_SNAKE_CASE_				):
                  UpperCamelCase :int										=     tf.zeros(self.model_tester.batch_size					,       dtype=tf.intaa				)
              elif model_class in [
                  *get_values(SCREAMING_SNAKE_CASE_				),
                  *get_values(SCREAMING_SNAKE_CASE_				),
                  *get_values(SCREAMING_SNAKE_CASE_				),
                  *get_values(SCREAMING_SNAKE_CASE_				),
                  *get_values(SCREAMING_SNAKE_CASE_				),
              ]:
                  UpperCamelCase :Any										=     tf.zeros(
                      (self.model_tester.batch_size, self.model_tester.seq_length)					,       dtype=tf.intaa				)
          return inputs_dict
      @slow
      def 					UpperCAmelCase		(       self				)       ->   int:
          UpperCamelCase							,     UpperCamelCase :List[Any]										=     self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
              UpperCamelCase :Tuple										=     self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :Dict										=     model_class(SCREAMING_SNAKE_CASE_				)

              @tf.function
              def run_in_graph_mode():
                  return model(SCREAMING_SNAKE_CASE_				)

              UpperCamelCase :List[Any]										=     run_in_graph_mode()
              self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
      @slow
      def 					UpperCAmelCase		(       self				)       ->   int:
          UpperCamelCase							,     UpperCamelCase :Tuple										=     self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
              UpperCamelCase :Union[str, Any]										=     self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :int										=     model_class(SCREAMING_SNAKE_CASE_				)

              @tf.function(experimental_compile=SCREAMING_SNAKE_CASE_				)
              def run_in_graph_mode():
                  return model(SCREAMING_SNAKE_CASE_				)

              UpperCamelCase :Union[str, Any]										=     run_in_graph_mode()
              self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
      @slow
      def 					UpperCAmelCase		(       self				)       ->   Dict:
          # This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
          UpperCamelCase							,     UpperCamelCase :Optional[int]										=     self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
              UpperCamelCase :Union[str, Any]										=     model_class(SCREAMING_SNAKE_CASE_				)
              if getattr(SCREAMING_SNAKE_CASE_					,       '''hf_compute_loss'''					,       SCREAMING_SNAKE_CASE_				):
                  # Test that model correctly compute the loss with kwargs
                  UpperCamelCase :str										=     self._prepare_for_class(inputs_dict.copy()					,       SCREAMING_SNAKE_CASE_					,       return_labels=SCREAMING_SNAKE_CASE_				)
                  # Is there a better way to remove these decoder inputs?
                  UpperCamelCase :Union[str, Any]										=     {
                      key: val
                      for key, val in prepared_for_class.items()
                      if key not in ('''head_mask''', '''decoder_head_mask''', '''cross_attn_head_mask''', '''decoder_input_ids''')
                  }

                  UpperCamelCase :str										=     {
                      '''labels''',
                      '''label''',
                      '''label_ids''',
                      '''start_positions''',
                      '''start_position''',
                      '''end_positions''',
                      '''end_position''',
                      '''next_sentence_label''',
                  }
                  UpperCamelCase :str										=     possible_label_cols.intersection(set(SCREAMING_SNAKE_CASE_				)				)
                  self.assertGreater(len(SCREAMING_SNAKE_CASE_				)					,       0					,       msg='''No matching label names found!'''				)
                  UpperCamelCase :Tuple										=     {key: val for key, val in prepared_for_class.items() if key in label_names}
                  UpperCamelCase :Any										=     {key: val for key, val in prepared_for_class.items() if key not in label_names}
                  self.assertGreater(len(SCREAMING_SNAKE_CASE_				)					,       0				)

                  # Make sure it works with XLA!
                  model.compile(optimizer=tf.keras.optimizers.SGD(0.0				)					,       jit_compile=SCREAMING_SNAKE_CASE_				)
                  # Make sure the model fits without crashing regardless of where we pass the labels
                  UpperCamelCase :Optional[int]										=     model.fit(
                      SCREAMING_SNAKE_CASE_					,       validation_data=SCREAMING_SNAKE_CASE_					,       steps_per_epoch=1					,       validation_steps=1					,       shuffle=SCREAMING_SNAKE_CASE_					,       verbose=0					,       )
                  UpperCamelCase :List[str]										=     history.history['''loss'''][0]
                  self.assertTrue(not isnan(SCREAMING_SNAKE_CASE_				)				)
                  UpperCamelCase :Tuple										=     history.history['''val_loss'''][0]
                  self.assertTrue(not isnan(SCREAMING_SNAKE_CASE_				)				)

                  # Now test it with separate labels, to make sure that path works in XLA too.
                  UpperCamelCase :Optional[Any]										=     model_class(SCREAMING_SNAKE_CASE_				)
                  model.compile(optimizer=tf.keras.optimizers.SGD(0.0				)					,       jit_compile=SCREAMING_SNAKE_CASE_				)
                  UpperCamelCase :str										=     model.fit(
                      SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       validation_data=(inputs_minus_labels, labels)					,       steps_per_epoch=1					,       validation_steps=1					,       shuffle=SCREAMING_SNAKE_CASE_					,       verbose=0					,       )

                  UpperCamelCase :str										=     history.history['''loss'''][0]
                  self.assertTrue(not isnan(SCREAMING_SNAKE_CASE_				)				)
                  UpperCamelCase :str										=     history.history['''val_loss'''][0]
                  self.assertTrue(not isnan(SCREAMING_SNAKE_CASE_				)				)
      @slow
      def 					UpperCAmelCase		(       self				)       ->   Any:
          UpperCamelCase							,     UpperCamelCase :Optional[Any]										=     self.model_tester.prepare_config_and_inputs_for_common()
          UpperCamelCase :Dict										=     True
          UpperCamelCase :Tuple										=     True

          if hasattr(SCREAMING_SNAKE_CASE_					,       '''use_cache'''				):
              UpperCamelCase :int										=     True

          UpperCamelCase :str										=     getattr(self.model_tester					,       '''encoder_seq_length'''					,       self.model_tester.seq_length				)
          UpperCamelCase :Any										=     getattr(self.model_tester					,       '''key_length'''					,       SCREAMING_SNAKE_CASE_				)

          for model_class in self.all_model_classes[:2]:
              UpperCamelCase :Tuple										=     self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :Union[str, Any]										=     model_class(SCREAMING_SNAKE_CASE_				)
              model.build()
              UpperCamelCase :str										=     len(model(SCREAMING_SNAKE_CASE_				)				)

              for key in list(class_inputs_dict.keys()				):
                  # Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
                  if key not in model.input_signature:
                      del class_inputs_dict[key]
                  # Check it's a tensor, in case the inputs dict has some bools in it too
                  elif isinstance(class_inputs_dict[key]					,       tf.Tensor				) and class_inputs_dict[key].dtype.is_integer:
                      UpperCamelCase :int										=     tf.cast(class_inputs_dict[key]					,       tf.intaa				)

              if set(class_inputs_dict.keys()				) != set(model.input_signature.keys()				):
                  continue  # Some models have inputs that the preparation functions don't create, we skip those

              with tempfile.TemporaryDirectory() as tmpdirname:
                  model.save_pretrained(SCREAMING_SNAKE_CASE_					,       saved_model=SCREAMING_SNAKE_CASE_				)
                  UpperCamelCase :int										=     os.path.join(SCREAMING_SNAKE_CASE_					,       '''saved_model'''					,       '''1'''				)
                  UpperCamelCase :Optional[int]										=     tf.keras.models.load_model(SCREAMING_SNAKE_CASE_				)
                  UpperCamelCase :Dict										=     model(SCREAMING_SNAKE_CASE_				)

                  if self.is_encoder_decoder:
                      UpperCamelCase :Any										=     outputs['''encoder_hidden_states''']
                      UpperCamelCase :List[str]										=     outputs['''encoder_attentions''']
                  else:
                      UpperCamelCase :Dict										=     outputs['''hidden_states''']
                      UpperCamelCase :str										=     outputs['''attentions''']

                  self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)

                  UpperCamelCase :List[str]										=     getattr(
                      self.model_tester					,       '''expected_num_hidden_layers'''					,       self.model_tester.num_hidden_layers + 1				)

                  self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)
                  self.assertListEqual(
                      list(output_hidden_states[0].shape[-2:]				)					,       [self.model_tester.seq_length, self.model_tester.hidden_size]					,       )

                  self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       self.model_tester.num_hidden_layers				)
                  self.assertListEqual(
                      list(output_attentions[0].shape[-3:]				)					,       [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,       )
      @slow
      def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
          tf.keras.mixed_precision.set_global_policy('''mixed_float16'''				)

          # try/finally block to ensure subsequent tests run in float32
          try:
              UpperCamelCase							,     UpperCamelCase :Union[str, Any]										=     self.model_tester.prepare_config_and_inputs_for_common()
              for model_class in self.all_model_classes[:2]:
                  UpperCamelCase :Optional[Any]										=     self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
                  UpperCamelCase :List[str]										=     model_class(SCREAMING_SNAKE_CASE_				)
                  UpperCamelCase :Dict										=     model(SCREAMING_SNAKE_CASE_				)

                  self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
          finally:
              tf.keras.mixed_precision.set_global_policy('''float32'''				)
      @slow
      def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
          UpperCamelCase							,     UpperCamelCase :Dict										=     self.model_tester.prepare_config_and_inputs_for_common()
          # head_mask and decoder_head_mask has different shapes than other input args
          if "head_mask" in inputs_dict:
              del inputs_dict["head_mask"]
          if "decoder_head_mask" in inputs_dict:
              del inputs_dict["decoder_head_mask"]
          if "cross_attn_head_mask" in inputs_dict:
              del inputs_dict["cross_attn_head_mask"]
          UpperCamelCase :Dict										=     {
              module_member
              for model_class in self.all_model_classes
              for module in (import_module(model_class.__module__				),)
              for module_member_name in dir(SCREAMING_SNAKE_CASE_				)
              if module_member_name.endswith('''MainLayer'''				)
              for module_member in (getattr(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				),)
              if isinstance(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
              and tf.keras.layers.Layer in module_member.__bases__
              and getattr(SCREAMING_SNAKE_CASE_					,       '''_keras_serializable'''					,       SCREAMING_SNAKE_CASE_				)
          }

          for main_layer_class in tf_main_layer_classes:
              # T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
              if "T5" in main_layer_class.__name__:
                  # Take the same values than in TFT5ModelTester for this shared layer
                  UpperCamelCase :List[str]										=     TFSharedEmbeddings(self.model_tester.vocab_size					,       self.model_tester.hidden_size					,       name='''shared'''				)
                  UpperCamelCase :Optional[Any]										=     False
                  UpperCamelCase :Optional[Any]										=     main_layer_class(SCREAMING_SNAKE_CASE_					,       embed_tokens=SCREAMING_SNAKE_CASE_				)
              else:
                  UpperCamelCase :Union[str, Any]										=     main_layer_class(SCREAMING_SNAKE_CASE_				)

              UpperCamelCase :Tuple										=     {
                  name: tf.keras.Input(tensor.shape[1:]					,       dtype=tensor.dtype				) for name, tensor in inputs_dict.items()
              }

              if hasattr(self.model_tester					,       '''num_labels'''				):
                  UpperCamelCase :Union[str, Any]										=     self.model_tester.num_labels
              else:
                  UpperCamelCase :List[str]										=     2

              UpperCamelCase :List[str]										=     tf.data.Dataset.from_tensor_slices(
                  (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)				))				).batch(1				)

              UpperCamelCase :int										=     main_layer(SCREAMING_SNAKE_CASE_				)[0]
              UpperCamelCase :Any										=     tf.keras.layers.Dense(SCREAMING_SNAKE_CASE_					,       activation='''softmax'''					,       name='''outputs'''				)(SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :List[Any]										=     tf.keras.models.Model(inputs=SCREAMING_SNAKE_CASE_					,       outputs=[outputs]				)

              model.compile(loss='''binary_crossentropy'''					,       optimizer='''adam'''					,       metrics=['''binary_accuracy''']				)
              model.fit(SCREAMING_SNAKE_CASE_					,       epochs=1				)

              with tempfile.TemporaryDirectory() as tmpdirname:
                  UpperCamelCase :Any										=     os.path.join(SCREAMING_SNAKE_CASE_					,       '''keras_model.h5'''				)
                  model.save(SCREAMING_SNAKE_CASE_				)
                  if "T5" in main_layer_class.__name__:
                      UpperCamelCase :List[str]										=     tf.keras.models.load_model(
                          SCREAMING_SNAKE_CASE_					,       custom_objects={
                              main_layer_class.__name__: main_layer_class,
                              '''TFSharedEmbeddings''': TFSharedEmbeddings,
                          }					,       )
                  else:
                      UpperCamelCase :Dict										=     tf.keras.models.load_model(
                          SCREAMING_SNAKE_CASE_					,       custom_objects={main_layer_class.__name__: main_layer_class}				)
                  assert isinstance(SCREAMING_SNAKE_CASE_					,       tf.keras.Model				)
                  model(SCREAMING_SNAKE_CASE_				)
      @slow
      def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
          UpperCamelCase							,     UpperCamelCase :Dict										=     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes[:2]:
              UpperCamelCase :str										=     model_class(SCREAMING_SNAKE_CASE_				)

              UpperCamelCase :int										=     copy.deepcopy(SCREAMING_SNAKE_CASE_				)

              if not self.is_encoder_decoder:
                  UpperCamelCase :int										=     inputs['''input_ids''']
                  del inputs["input_ids"]
              else:
                  UpperCamelCase :Any										=     inputs['''input_ids''']
                  UpperCamelCase :Dict										=     inputs.get('''decoder_input_ids'''					,       SCREAMING_SNAKE_CASE_				)
                  del inputs["input_ids"]
                  inputs.pop('''decoder_input_ids'''					,       SCREAMING_SNAKE_CASE_				)

              if not self.is_encoder_decoder:
                  UpperCamelCase :List[str]										=     model.get_input_embeddings()(SCREAMING_SNAKE_CASE_				)
              else:
                  UpperCamelCase :int										=     model.get_input_embeddings()(SCREAMING_SNAKE_CASE_				)
                  UpperCamelCase :str										=     model.get_input_embeddings()(SCREAMING_SNAKE_CASE_				)

              UpperCamelCase :str										=     self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)

              @tf.function
              def run_in_graph_mode():
                  return model(SCREAMING_SNAKE_CASE_				)

              UpperCamelCase :Tuple										=     run_in_graph_mode()
              self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Optional[int]:
          # special tokens cannot be bad tokens
          UpperCamelCase :Tuple										=     []
          if model.config.bos_token_id is not None:
              special_tokens.append(model.config.bos_token_id				)
          if model.config.pad_token_id is not None:
              special_tokens.append(model.config.pad_token_id				)
          if model.config.eos_token_id is not None:
              special_tokens.append(model.config.eos_token_id				)

          # create random bad tokens that are not special tokens
          UpperCamelCase :Optional[Any]										=     []
          while len(SCREAMING_SNAKE_CASE_				) < num_bad_tokens:
              UpperCamelCase :Tuple										=     tf.squeeze(ids_tensor((1, 1)					,       self.model_tester.vocab_size				)					,       0				).numpy()[0]
              if token not in special_tokens:
                  bad_tokens.append(SCREAMING_SNAKE_CASE_				)
          return bad_tokens
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_				)       ->   List[str]:
          for token_id in output_ids[0].numpy().tolist():
              self.assertGreaterEqual(SCREAMING_SNAKE_CASE_					,       0				)
              self.assertLess(SCREAMING_SNAKE_CASE_					,       self.model_tester.vocab_size				)




      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Dict:
          # for all bad word tokens
          for bad_word_ids in bad_words_ids:
              # for all slices in batch
              for generated_ids_slice in generated_ids:
                  # for all word idx
                  for i in range(len(SCREAMING_SNAKE_CASE_				)					,       len(SCREAMING_SNAKE_CASE_				)				):
                      # if tokens match
                      if generated_ids_slice[i - len(SCREAMING_SNAKE_CASE_				) : i] == bad_word_ids:
                          return True
          return False













from typing import TYPE_CHECKING

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


__snake_case							      =						{
    """configuration_open_llama""": ["""OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OpenLlamaConfig"""],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __snake_case							      =						["""LlamaTokenizer"""]

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __snake_case							      =						["""LlamaTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __snake_case							      =						[
     """OpenLlamaForCausalLM""",
     """OpenLlamaModel""",
     """OpenLlamaPreTrainedModel""",
     """OpenLlamaForSequenceClassification""",
 ]


if TYPE_CHECKING:
 from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from transformers import LlamaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from transformers import LlamaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_open_llama import (
      OpenLlamaForCausalLM,
      OpenLlamaForSequenceClassification,
      OpenLlamaModel,
      OpenLlamaPreTrainedModel,
  )


else:
 import sys

 __snake_case							      =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





