






'''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 							__SCREAMING_SNAKE_CASE       :




      def __init__(  self ,   lowerCamelCase ,   lowerCamelCase=13 ,   lowerCamelCase=7 ,   lowerCamelCase=True ,   lowerCamelCase=True ,   lowerCamelCase=False ,   lowerCamelCase=True ,   lowerCamelCase=99 ,   lowerCamelCase=32 ,   lowerCamelCase=5 ,   lowerCamelCase=4 ,   lowerCamelCase=37 ,   lowerCamelCase="gelu" ,   lowerCamelCase=0.1 ,   lowerCamelCase=0.1 ,   lowerCamelCase=512 ,   lowerCamelCase=16 ,   lowerCamelCase=2 ,   lowerCamelCase=0.02 ,   lowerCamelCase=3 ,   lowerCamelCase=4 ,   lowerCamelCase=None ,   )							->Union[str, Any]:



         '''simple docstring'''
         __a				     =    parent
         __a				     =    batch_size
         __a				     =    seq_length
         __a				     =    is_training
         __a				     =    use_input_mask
         __a				     =    use_token_type_ids
         __a				     =    use_labels
         __a				     =    vocab_size
         __a				     =    hidden_size
         __a				     =    num_hidden_layers
         __a				     =    num_attention_heads
         __a				     =    intermediate_size
         __a				     =    hidden_act
         __a				     =    hidden_dropout_prob
         __a				     =    attention_probs_dropout_prob
         __a				     =    max_position_embeddings
         __a				     =    type_vocab_size
         __a				     =    type_sequence_label_size
         __a				     =    initializer_range
         __a				     =    num_labels
         __a				     =    num_choices
         __a				     =    scope




      def  __UpperCamelCase							(  self      )							->int:



         '''simple docstring'''
         __a				     =    ids_tensor([self.batch_size, self.seq_length] ,   self.vocab_size      )

         __a				     =    None
         if self.use_input_mask:
            __a				     =    random_attention_mask([self.batch_size, self.seq_length]      )

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

         __a				     =    None
         __a				     =    None
         __a				     =    None
         if self.use_labels:
            __a				     =    ids_tensor([self.batch_size] ,   self.type_sequence_label_size      )
            __a				     =    ids_tensor([self.batch_size, self.seq_length] ,   self.num_labels      )
            __a				     =    ids_tensor([self.batch_size] ,   self.num_choices      )

         __a				     =    self.get_config()

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




      def  __UpperCamelCase							(  self      )							->Union[str, Any]:



         '''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=lowerCamelCase ,   initializer_range=self.initializer_range ,   use_stable_embedding=lowerCamelCase ,   )




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )							->Tuple:



         '''simple docstring'''
         __a				     =    OpenLlamaModel(config=lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()
         __a				     =    model(lowerCamelCase ,   attention_mask=lowerCamelCase      )
         __a				     =    model(lowerCamelCase      )
         self.parent.assertEqual(result.last_hidden_state.shape ,   (self.batch_size, self.seq_length, self.hidden_size)      )




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   )							->Optional[int]:



         '''simple docstring'''
         __a				     =    True
         __a				     =    OpenLlamaModel(lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()
         __a				     =    model(
             lowerCamelCase ,   attention_mask=lowerCamelCase ,   encoder_hidden_states=lowerCamelCase ,   encoder_attention_mask=lowerCamelCase ,   )
         __a				     =    model(
             lowerCamelCase ,   attention_mask=lowerCamelCase ,   encoder_hidden_states=lowerCamelCase ,   )
         __a				     =    model(lowerCamelCase ,   attention_mask=lowerCamelCase      )
         self.parent.assertEqual(result.last_hidden_state.shape ,   (self.batch_size, self.seq_length, self.hidden_size)      )




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   )							->Union[str, Any]:



         '''simple docstring'''
         __a				     =    OpenLlamaForCausalLM(config=lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()
         __a				     =    model(lowerCamelCase ,   attention_mask=lowerCamelCase ,   labels=lowerCamelCase      )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.seq_length, self.vocab_size)      )




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   )							->Union[str, Any]:



         '''simple docstring'''
         __a				     =    True
         __a				     =    True
         __a				     =    OpenLlamaForCausalLM(config=lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()

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

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

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

         __a				     =    model(
             lowerCamelCase ,   attention_mask=lowerCamelCase ,   encoder_hidden_states=lowerCamelCase ,   encoder_attention_mask=lowerCamelCase ,   output_hidden_states=lowerCamelCase ,   )['hidden_states'][0]
         __a				     =    model(
             lowerCamelCase ,   attention_mask=lowerCamelCase ,   encoder_hidden_states=lowerCamelCase ,   encoder_attention_mask=lowerCamelCase ,   past_key_values=lowerCamelCase ,   output_hidden_states=lowerCamelCase ,   )['hidden_states'][0]

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






      def  __UpperCamelCase							(  self      )							->List[str]:



         '''simple docstring'''
         __a				     =    self.prepare_config_and_inputs()
         (
             (
             __a
         )     ,			(
             __a
         )     ,			(
             __a
         )     ,			(
             __a
         )     ,			(
             __a
         )     ,			(
             __a
         )     ,			(
             __a
         )     ,			
         )				     =    config_and_inputs
         __a				     =    {'input_ids': input_ids, 'attention_mask': input_mask}
         return config, inputs_dict







@require_torch
class 							__SCREAMING_SNAKE_CASE       (							_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      unittest.TestCase     ):
      __a  					=(
          (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
      )
      __a  					=(OpenLlamaForCausalLM,) if is_torch_available() else ()
      __a  					=(
          {
              "feature-extraction": OpenLlamaModel,
              "text-classification": OpenLlamaForSequenceClassification,
              "text-generation": OpenLlamaForCausalLM,
              "zero-shot": OpenLlamaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      __a  					=False
      __a  					=False




      def  __UpperCamelCase							(  self      )							->str:



         '''simple docstring'''
         __a				     =    OpenLlamaModelTester(self      )
         __a				     =    ConfigTester(self ,   config_class=lowerCamelCase ,   hidden_size=37      )




      def  __UpperCamelCase							(  self      )							->Union[str, Any]:



         '''simple docstring'''
         self.config_tester.run_common_tests()




      def  __UpperCamelCase							(  self      )							->Optional[int]:



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->Tuple:



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
            __a				     =    type
            self.model_tester.create_and_check_model(*lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->List[Any]:



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




      def  __UpperCamelCase							(  self      )							->Optional[int]:



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




      def  __UpperCamelCase							(  self      )							->Tuple:



         '''simple docstring'''
         __a     ,			__a				     =    self.model_tester.prepare_config_and_inputs_for_common()
         __a				     =    3
         __a				     =    'multi_label_classification'
         __a				     =    input_dict['input_ids']
         __a				     =    input_ids.ne(1      ).to(lowerCamelCase      )
         __a				     =    ids_tensor(
             [self.model_tester.batch_size, config.num_labels] ,   self.model_tester.type_sequence_label_size      ).to(torch.float      )
         __a				     =    OpenLlamaForSequenceClassification(lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()
         __a				     =    model(lowerCamelCase ,   attention_mask=lowerCamelCase ,   labels=lowerCamelCase      )
         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      )							->Any:



         '''simple docstring'''
         pass






      @parameterized.expand([('linear',), ('dynamic',)]      )
      def  __UpperCamelCase							(  self ,   lowerCamelCase      )							->int:



         '''simple docstring'''
         __a     ,			__a				     =    self.model_tester.prepare_config_and_inputs_for_common()
         __a				     =    ids_tensor([1, 10] ,   config.vocab_size      )
         __a				     =    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
         __a				     =    OpenLlamaModel(lowerCamelCase      )
         original_model.to(lowerCamelCase      )
         original_model.eval()
         __a				     =    original_model(lowerCamelCase      ).last_hidden_state
         __a				     =    original_model(lowerCamelCase      ).last_hidden_state

         set_seed(42      )  # Fixed seed at init time so the two models get the same random weights
         __a				     =    {'type': scaling_type, 'factor': 10.0}
         __a				     =    OpenLlamaModel(lowerCamelCase      )
         scaled_model.to(lowerCamelCase      )
         scaled_model.eval()
         __a				     =    scaled_model(lowerCamelCase      ).last_hidden_state
         __a				     =    scaled_model(lowerCamelCase      ).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(lowerCamelCase ,   lowerCamelCase ,   atol=1e-5      )      )
         else:
            self.assertFalse(torch.allclose(lowerCamelCase ,   lowerCamelCase ,   atol=1e-5      )      )

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







'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCamelCase      :       Tuple      			=      {
    """configuration_blip_2""": [
        """BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """Blip2Config""",
        """Blip2QFormerConfig""",
        """Blip2VisionConfig""",
    ],
    """processing_blip_2""": ["""Blip2Processor"""],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __UpperCamelCase      :       Optional[int]      			=      [
     """BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """Blip2Model""",
     """Blip2QFormerModel""",
     """Blip2PreTrainedModel""",
     """Blip2ForConditionalGeneration""",
     """Blip2VisionModel""",
 ]

if TYPE_CHECKING:
 from .configuration_blip_a import (
     BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP,
     BlipaConfig,
     BlipaQFormerConfig,
     BlipaVisionConfig,
 )
 from .processing_blip_a import BlipaProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_blip_a import (
      BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST,
      BlipaForConditionalGeneration,
      BlipaModel,
      BlipaPreTrainedModel,
      BlipaQFormerModel,
      BlipaVisionModel,
  )

else:
 import sys

 __UpperCamelCase      :       Dict      			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)