


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


a					  =     {
    'configuration_mobilevit': ['MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MobileViTConfig', 'MobileViTOnnxConfig'],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a					  =     ['MobileViTFeatureExtractor']
       a					  =     ['MobileViTImageProcessor']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a					  =     [
           'MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'MobileViTForImageClassification',
           'MobileViTForSemanticSegmentation',
           'MobileViTModel',
           'MobileViTPreTrainedModel',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a					  =     [
           'TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'TFMobileViTForImageClassification',
           'TFMobileViTForSemanticSegmentation',
           'TFMobileViTModel',
           'TFMobileViTPreTrainedModel',
       ]

if TYPE_CHECKING:
       from .configuration_mobilevit import MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, MobileViTConfig, MobileViTOnnxConfig

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_mobilevit import MobileViTFeatureExtractor
              from .image_processing_mobilevit import MobileViTImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_mobilevit import (
                  MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  MobileViTForImageClassification,
                  MobileViTForSemanticSegmentation,
                  MobileViTModel,
                  MobileViTPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_mobilevit import (
                  TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFMobileViTForImageClassification,
                  TFMobileViTForSemanticSegmentation,
                  TFMobileViTModel,
                  TFMobileViTPreTrainedModel,
              )


else:
       import sys

       a					  =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






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       :   List[str]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   List[str]=13							,					UpperCamelCase__       :   str=7							,					UpperCamelCase__       :   List[str]=True							,					UpperCamelCase__       :   List[str]=True							,					UpperCamelCase__       :   str=False							,					UpperCamelCase__       :   str=True							,					UpperCamelCase__       :   Union[str, Any]=99							,					UpperCamelCase__       :   Dict=32							,					UpperCamelCase__       :   Union[str, Any]=5							,					UpperCamelCase__       :   Tuple=4							,					UpperCamelCase__       :   Dict=37							,					UpperCamelCase__       :   Any="gelu"							,					UpperCamelCase__       :   Dict=0.1							,					UpperCamelCase__       :   Tuple=0.1							,					UpperCamelCase__       :   Tuple=512							,					UpperCamelCase__       :   Union[str, Any]=16							,					UpperCamelCase__       :   List[str]=2							,					UpperCamelCase__       :   int=0.02							,					UpperCamelCase__       :   int=3							,					UpperCamelCase__       :   Optional[Any]=4							,					UpperCamelCase__       :   int=None							,					):






										'''simple docstring'''






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

					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size       )

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

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

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

										lowercase_  							=			self.get_config()

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

					def   UpperCAmelCase__       (     self       :   Dict       ):






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

					def   UpperCAmelCase__       (     self       :   str							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Dict							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   Dict							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			OpenLlamaModel(config=UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__       )
										lowercase_  							=			model(UpperCamelCase__       )
										self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)       )

					def   UpperCAmelCase__       (     self       :   Union[str, Any]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   Optional[Any]							,					):






										'''simple docstring'''






										lowercase_  							=			True
										lowercase_  							=			OpenLlamaModel(UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					encoder_attention_mask=UpperCamelCase__							,					)
										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					)
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__       )
										self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)       )

					def   UpperCAmelCase__       (     self       :   Any							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   List[Any]							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Any							,					UpperCamelCase__       :   Union[str, Any]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Any							,					UpperCamelCase__       :   List[Any]							,					):






										'''simple docstring'''






										lowercase_  							=			OpenLlamaForCausalLM(config=UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					labels=UpperCamelCase__       )
										self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.vocab_size)       )

					def   UpperCAmelCase__       (     self       :   int							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Tuple							,					):






										'''simple docstring'''






										lowercase_  							=			True
										lowercase_  							=			True
										lowercase_  							=			OpenLlamaForCausalLM(config=UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()

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

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

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

										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					encoder_attention_mask=UpperCamelCase__							,					output_hidden_states=UpperCamelCase__							,					)["""hidden_states"""][0]
										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					encoder_attention_mask=UpperCamelCase__							,					past_key_values=UpperCamelCase__							,					output_hidden_states=UpperCamelCase__							,					)["""hidden_states"""][0]

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







					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			self.prepare_config_and_inputs()
										(
										    (
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					
										)  							=			config_and_inputs
										lowercase_  							=			{"""input_ids""": input_ids, """attention_mask""": input_mask}
										return config, inputs_dict







@require_torch
class        UpperCamelCase__   (	__magic_name__							,				__magic_name__							,				__magic_name__							,				unittest.TestCase   ):
					__SCREAMING_SNAKE_CASE       :  Union[str, Any]						=   (
					    (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
					)
					__SCREAMING_SNAKE_CASE       :  List[str]						=   (OpenLlamaForCausalLM,) if is_torch_available() else ()
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   (
					    {
					        'feature-extraction': OpenLlamaModel,
					        'text-classification': OpenLlamaForSequenceClassification,
					        'text-generation': OpenLlamaForCausalLM,
					        'zero-shot': OpenLlamaForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					__SCREAMING_SNAKE_CASE       :  Tuple						=   False
					__SCREAMING_SNAKE_CASE       :  Optional[int]						=   False

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										lowercase_  							=			OpenLlamaModelTester(self       )
										lowercase_  							=			ConfigTester(self							,					config_class=UpperCamelCase__							,					hidden_size=37       )

					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										self.config_tester.run_common_tests()

					def   UpperCAmelCase__       (     self       :   str       ):






										'''simple docstring'''






										lowercase_  							=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										lowercase_  							=			self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
															lowercase_  							=			type
															self.model_tester.create_and_check_model(*UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






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

					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






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

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										lowercase_							,					lowercase_  							=			self.model_tester.prepare_config_and_inputs_for_common()
										lowercase_  							=			3
										lowercase_  							=			"""multi_label_classification"""
										lowercase_  							=			input_dict["""input_ids"""]
										lowercase_  							=			input_ids.ne(1       ).to(UpperCamelCase__       )
										lowercase_  							=			ids_tensor(
										    [self.model_tester.batch_size, config.num_labels]							,					self.model_tester.type_sequence_label_size       ).to(torch.float       )
										lowercase_  							=			OpenLlamaForSequenceClassification(UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					labels=UpperCamelCase__       )
										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       :   Dict       ):






										'''simple docstring'''






										pass







					@parameterized.expand([("""linear""",), ("""dynamic""",)]       )
					def   UpperCAmelCase__       (     self       :   Tuple							,					UpperCamelCase__       :   Union[str, Any]       ):






										'''simple docstring'''






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

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

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


