



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     _UpperCAmelCase			:




     def __init__(				self ,						a__ ,						a__=1_3 ,						a__=7 ,						a__=True ,						a__=True ,						a__=False ,						a__=True ,						a__=9_9 ,						a__=3_2 ,						a__=5 ,						a__=4 ,						a__=3_7 ,						a__="gelu" ,						a__=0.1 ,						a__=0.1 ,						a__=5_1_2 ,						a__=1_6 ,						a__=2 ,						a__=0.0_2 ,						a__=3 ,						a__=4 ,						a__=None ,						):
         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 		snake_case_		(				self):
         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 		snake_case_		(				self):
         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=a__ ,						initializer_range=self.initializer_range ,						use_stable_embedding=a__ ,						)




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__):
         A__		 =					OpenLlamaModel(config=a__)
         model.to(a__)
         model.eval()
         A__		 =					model(a__ ,						attention_mask=a__)
         A__		 =					model(a__)
         self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size))




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					True
         A__		 =					OpenLlamaModel(a__)
         model.to(a__)
         model.eval()
         A__		 =					model(
             a__ ,						attention_mask=a__ ,						encoder_hidden_states=a__ ,						encoder_attention_mask=a__ ,						)
         A__		 =					model(
             a__ ,						attention_mask=a__ ,						encoder_hidden_states=a__ ,						)
         A__		 =					model(a__ ,						attention_mask=a__)
         self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size))




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					OpenLlamaForCausalLM(config=a__)
         model.to(a__)
         model.eval()
         A__		 =					model(a__ ,						attention_mask=a__ ,						labels=a__)
         self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size))




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					True
         A__		 =					True
         A__		 =					OpenLlamaForCausalLM(config=a__)
         model.to(a__)
         model.eval()

         # first forward pass
         A__		 =					model(
             a__ ,						attention_mask=a__ ,						encoder_hidden_states=a__ ,						encoder_attention_mask=a__ ,						use_cache=a__ ,						)
         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(
             a__ ,						attention_mask=a__ ,						encoder_hidden_states=a__ ,						encoder_attention_mask=a__ ,						output_hidden_states=a__ ,						)['''hidden_states'''][0]
         A__		 =					model(
             a__ ,						attention_mask=a__ ,						encoder_hidden_states=a__ ,						encoder_attention_mask=a__ ,						past_key_values=a__ ,						output_hidden_states=a__ ,						)['''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(a__ ,						a__ ,						atol=1e-3))




     def 		snake_case_		(				self):
         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     _UpperCAmelCase			(       A__			,      A__			,      A__			,      unittest.TestCase     ):
     UpperCamelCase__		    =				(
         (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
     )
     UpperCamelCase__		    =				(OpenLlamaForCausalLM,) if is_torch_available() else ()
     UpperCamelCase__		    =				(
         {
             '''feature-extraction''': OpenLlamaModel,
             '''text-classification''': OpenLlamaForSequenceClassification,
             '''text-generation''': OpenLlamaForCausalLM,
             '''zero-shot''': OpenLlamaForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     UpperCamelCase__		    =				False
     UpperCamelCase__		    =				False




     def 		snake_case_		(				self):
         A__		 =					OpenLlamaModelTester(self)
         A__		 =					ConfigTester(self ,						config_class=a__ ,						hidden_size=3_7)




     def 		snake_case_		(				self):
         self.config_tester.run_common_tests()




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a__)




     def 		snake_case_		(				self):
         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(*a__)




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




     def 		snake_case_		(				self):
         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(a__)
         A__		 =					ids_tensor([self.model_tester.batch_size] ,						self.model_tester.type_sequence_label_size)
         A__		 =					OpenLlamaForSequenceClassification(a__)
         model.to(a__)
         model.eval()
         A__		 =					model(a__ ,						attention_mask=a__ ,						labels=a__)
         self.assertEqual(result.logits.shape ,						(self.model_tester.batch_size, self.model_tester.num_labels))




     def 		snake_case_		(				self):
         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(a__)
         A__		 =					ids_tensor(
             [self.model_tester.batch_size, config.num_labels] ,						self.model_tester.type_sequence_label_size).to(torch.float)
         A__		 =					OpenLlamaForSequenceClassification(a__)
         model.to(a__)
         model.eval()
         A__		 =					model(a__ ,						attention_mask=a__ ,						labels=a__)
         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 		snake_case_		(				self):
         pass




     @parameterized.expand([('''linear''',), ('''dynamic''',)])
     def 		snake_case_		(				self ,						a__):
         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()
         A__		 =					ids_tensor([1, 1_0] ,						config.vocab_size)
         A__		 =					ids_tensor([1, int(config.max_position_embeddings * 1.5)] ,						config.vocab_size)

         set_seed(4_2)  # Fixed seed at init time so the two models get the same random weights
         A__		 =					OpenLlamaModel(a__)
         original_model.to(a__)
         original_model.eval()
         A__		 =					original_model(a__).last_hidden_state
         A__		 =					original_model(a__).last_hidden_state

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

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





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
   from PIL import Image



class     _UpperCAmelCase			(       A__     ):
     UpperCamelCase__		    =				'''Salesforce/blip-image-captioning-base'''
     UpperCamelCase__		    =				(
         '''This is a tool that generates a description of an image. It takes an input named `image` which should be the '''
         '''image to caption, and returns a text that contains the description in English.'''
     )
     UpperCamelCase__		    =				'''image_captioner'''
     UpperCamelCase__		    =				AutoModelForVisionaSeq

     UpperCamelCase__		    =				['''image''']
     UpperCamelCase__		    =				['''text''']




     def __init__(				self ,						*a__ ,						**a__):
         requires_backends(self ,						['''vision'''])
         super().__init__(*a__ ,						**a__)




     def 		snake_case_		(				self ,						a__):
         return self.pre_processor(images=a__ ,						return_tensors='''pt''')




     def 		snake_case_		(				self ,						a__):
         return self.model.generate(**a__)




     def 		snake_case_		(				self ,						a__):
         return self.pre_processor.batch_decode(a__ ,						skip_special_tokens=a__)[0].strip()
