





'''simple docstring'''






import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A   : Tuple             =			logging.get_logger(__name__)

A   : List[str]             =			{
    'microsoft/git-base': 'https://huggingface.co/microsoft/git-base/resolve/main/config.json',
}







class 			lowerCamelCase					(						__UpperCAmelCase  ):
					_SCREAMING_SNAKE_CASE							   =    "git_vision_model"


					def __init__(					self	:  str       ,     __snake_case	:  Dict=7_68       ,     __snake_case	:  str=30_72       ,     __snake_case	:  Dict=12       ,     __snake_case	:  Dict=12       ,     __snake_case	:  Optional[int]=3       ,     __snake_case	:  List[Any]=2_24       ,     __snake_case	:  Dict=16       ,     __snake_case	:  int="quick_gelu"       ,     __snake_case	:  List[str]=1e-5       ,     __snake_case	:  Optional[int]=0.0       ,     __snake_case	:  List[Any]=0.02       ,     **__snake_case	:  int       ,     ):





											'''simple docstring'''





											super().__init__(**__snake_case       )

											_snake_case:   Optional[int]  					=		hidden_size
											_snake_case:   Any  					=		intermediate_size
											_snake_case:   Union[str, Any]  					=		num_hidden_layers
											_snake_case:   Optional[int]  					=		num_attention_heads
											_snake_case:   int  					=		num_channels
											_snake_case:   Tuple  					=		patch_size
											_snake_case:   List[str]  					=		image_size
											_snake_case:   Optional[int]  					=		initializer_range
											_snake_case:   Tuple  					=		attention_dropout
											_snake_case:   str  					=		layer_norm_eps
											_snake_case:   Union[str, Any]  					=		hidden_act




					@classmethod
					def    SCREAMING_SNAKE_CASE_		(					cls	:  List[str]       ,     __snake_case	:  Union[str, os.PathLike]       ,     **__snake_case	:  List[str]       ):





											'''simple docstring'''





											cls._set_token_in_kwargs(__snake_case       )

											_snake_case					,						_snake_case:   List[str]  					=		cls.get_config_dict(__snake_case       ,     **__snake_case       )

											# get the vision config dict if we are loading from GITConfig
											if config_dict.get('model_type'       ) == "git":
																	_snake_case:   str  					=		config_dict['vision_config']

											if "model_type" in config_dict and hasattr(cls       ,     'model_type'       ) and config_dict["model_type"] != cls.model_type:
																	logger.warning(
																	    f'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
																	    f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''       )

											return cls.from_dict(__snake_case       ,     **__snake_case       )







class 			lowerCamelCase					(						__UpperCAmelCase  ):
					_SCREAMING_SNAKE_CASE							   =    "git"


					def __init__(					self	:  int       ,     __snake_case	:  Tuple=None       ,     __snake_case	:  str=3_05_22       ,     __snake_case	:  Any=7_68       ,     __snake_case	:  List[Any]=6       ,     __snake_case	:  Optional[Any]=12       ,     __snake_case	:  Tuple=30_72       ,     __snake_case	:  Dict="gelu"       ,     __snake_case	:  Union[str, Any]=0.1       ,     __snake_case	:  str=0.1       ,     __snake_case	:  Optional[Any]=10_24       ,     __snake_case	:  Any=0.02       ,     __snake_case	:  Union[str, Any]=1e-12       ,     __snake_case	:  Any=0       ,     __snake_case	:  Union[str, Any]="absolute"       ,     __snake_case	:  str=True       ,     __snake_case	:  int=False       ,     __snake_case	:  Union[str, Any]=1_01       ,     __snake_case	:  Optional[int]=1_02       ,     __snake_case	:  int=None       ,     **__snake_case	:  Tuple       ,     ):





											'''simple docstring'''





											super().__init__(bos_token_id=__snake_case       ,     eos_token_id=__snake_case       ,     pad_token_id=__snake_case       ,     **__snake_case       )

											if vision_config is None:
																	_snake_case:   Optional[int]  					=		{}
																	logger.info('vision_config is None. initializing the GitVisionConfig with default values.'       )

											_snake_case:   List[Any]  					=		GitVisionConfig(**__snake_case       )
											_snake_case:   Tuple  					=		vocab_size
											_snake_case:   Optional[Any]  					=		hidden_size
											_snake_case:   List[str]  					=		num_hidden_layers
											_snake_case:   Dict  					=		num_attention_heads
											_snake_case:   Union[str, Any]  					=		hidden_act
											_snake_case:   Optional[int]  					=		intermediate_size
											_snake_case:   Any  					=		hidden_dropout_prob
											_snake_case:   int  					=		attention_probs_dropout_prob
											_snake_case:   List[Any]  					=		max_position_embeddings
											_snake_case:   Optional[Any]  					=		initializer_range
											_snake_case:   str  					=		layer_norm_eps
											_snake_case:   Tuple  					=		position_embedding_type
											_snake_case:   Optional[int]  					=		use_cache
											_snake_case:   Any  					=		tie_word_embeddings
											_snake_case:   List[Any]  					=		num_image_with_embedding

											_snake_case:   Dict  					=		bos_token_id
											_snake_case:   Optional[Any]  					=		eos_token_id




					def    SCREAMING_SNAKE_CASE_		(					self	:  int       ):





											'''simple docstring'''





											_snake_case:   Dict  					=		copy.deepcopy(self.__dict__       )
											_snake_case:   Tuple  					=		self.vision_config.to_dict()
											_snake_case:   Optional[Any]  					=		self.__class__.model_type
											return output












'''simple docstring'''






import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
		import tensorflow as tf

if is_tensorflow_text_available():
		from transformers.models.bert import TFBertTokenizer


A   : Tuple             =			['bert-base-uncased', 'bert-base-cased']
A   : str             =			'hf-internal-testing/tiny-bert-tf-only'

if is_tf_available():







		class 			lowerCamelCase					(						tf.keras.Model  ):


							def __init__(					self	:  Union[str, Any]       ,     __snake_case	:  List[Any]       ):





													'''simple docstring'''





													super().__init__()
													_snake_case:   List[Any]  					=		tokenizer
													_snake_case:   str  					=		AutoConfig.from_pretrained(__snake_case       )
													_snake_case:   List[Any]  					=		TFAutoModel.from_config(__snake_case       )




							def    SCREAMING_SNAKE_CASE_		(					self	:  str       ,     __snake_case	:  List[str]       ):





													'''simple docstring'''





													_snake_case:   Optional[int]  					=		self.tokenizer(__snake_case       )
													_snake_case:   Tuple  					=		self.bert(**__snake_case       )
													return out["pooler_output"]







@require_tf
@require_tensorflow_text
class 			lowerCamelCase					(						unittest.TestCase  ):


					def    SCREAMING_SNAKE_CASE_		(					self	:  Tuple       ):





											'''simple docstring'''





											super().setUp()

											_snake_case:   List[Any]  					=		[
											    BertTokenizer.from_pretrained(__snake_case       ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
											]  # repeat for when fast_bert_tokenizer=false
											_snake_case:   List[Any]  					=		[TFBertTokenizer.from_pretrained(__snake_case       ) for checkpoint in TOKENIZER_CHECKPOINTS] + [
											    TFBertTokenizer.from_pretrained(__snake_case       ,     use_fast_bert_tokenizer=__snake_case       )
											    for checkpoint in TOKENIZER_CHECKPOINTS
											]
											assert len(self.tokenizers       ) == len(self.tf_tokenizers       )

											_snake_case:   int  					=		[
											    'This is a straightforward English test sentence.',
											    'This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.',
											    'Now we\'re going to add some Chinese: 一 二 三 一二三',
											    'And some much more rare Chinese: 齉 堃 齉堃',
											    'Je vais aussi écrire en français pour tester les accents',
											    'Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ',
											]
											_snake_case:   str  					=		list(zip(self.test_sentences       ,     self.test_sentences[::-1]       )       )


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





											'''simple docstring'''





											for tokenizer, tf_tokenizer in zip(self.tokenizers       ,     self.tf_tokenizers       ):
																	for test_inputs in (self.test_sentences, self.paired_sentences):
																							_snake_case:   List[Any]  					=		tokenizer(__snake_case       ,     return_tensors='tf'       ,     padding='longest'       )
																							_snake_case:   Optional[Any]  					=		tf_tokenizer(__snake_case       )

																							for key in python_outputs.keys():
																													self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape       )       )
																													self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]       ,     tf.intaa       ) == tf_outputs[key]       )       )


					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  int       ):





											'''simple docstring'''





											for tf_tokenizer in self.tf_tokenizers:
																	_snake_case:   str  					=		tf_tokenizer(self.paired_sentences       )
																	_snake_case:   Any  					=		tf_tokenizer(
																	    text=[sentence[0] for sentence in self.paired_sentences]       ,     text_pair=[sentence[1] for sentence in self.paired_sentences]       ,     )
																	for key in merged_outputs.keys():
																							self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]       ,     tf.intaa       ) == separated_outputs[key]       )       )


					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  Tuple       ):





											'''simple docstring'''





											for tf_tokenizer in self.tf_tokenizers:
																	_snake_case:   List[str]  					=		tf.function(__snake_case       )
																	for test_inputs in (self.test_sentences, self.paired_sentences):
																							_snake_case:   Union[str, Any]  					=		tf.constant(__snake_case       )
																							_snake_case:   Any  					=		compiled_tokenizer(__snake_case       )
																							_snake_case:   Union[str, Any]  					=		tf_tokenizer(__snake_case       )

																							for key in eager_outputs.keys():
																													self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]       )       )




					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  List[str]       ):





											'''simple docstring'''





											for tf_tokenizer in self.tf_tokenizers:
																	_snake_case:   Optional[Any]  					=		ModelToSave(tokenizer=__snake_case       )
																	_snake_case:   Tuple  					=		tf.convert_to_tensor(self.test_sentences       )
																	_snake_case:   List[str]  					=		model(__snake_case       )  # Build model with some sample inputs
																	with TemporaryDirectory() as tempdir:
																							_snake_case:   List[str]  					=		Path(__snake_case       ) / 'saved.model'
																							model.save(__snake_case       )
																							_snake_case:   int  					=		tf.keras.models.load_model(__snake_case       )
																	_snake_case:   int  					=		loaded_model(__snake_case       )
																	# We may see small differences because the loaded model is compiled, so we need an epsilon for the test
																	self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output       )       )       ,     1e-5       )





