



"""simple docstring"""







import copy
import os
from typing import Union

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


A    =			logging.get_logger(__name__)

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






class      UpperCAmelCase__		(      UpperCamelCase     ):
		lowerCAmelCase_       :	Dict 							=     """git_vision_model"""



		def __init__( self  :    List[str]      ,							snake_case  :    Union[str, Any]=768      ,							snake_case  :    List[Any]=3_072      ,							snake_case  :    Any=12      ,							snake_case  :    Tuple=12      ,							snake_case  :    Dict=3      ,							snake_case  :    Union[str, Any]=224      ,							snake_case  :    str=16      ,							snake_case  :    List[str]="quick_gelu"      ,							snake_case  :    str=1E-5      ,							snake_case  :    int=0.0      ,							snake_case  :    Optional[int]=0.02      ,							**snake_case  :    Optional[Any]      ,							)			->						List[str]:






									'''simple docstring'''

									super().__init__(**snake_case				)

									A         =					hidden_size
									A         =					intermediate_size
									A         =					num_hidden_layers
									A         =					num_attention_heads
									A         =					num_channels
									A         =					patch_size
									A         =					image_size
									A         =					initializer_range
									A         =					attention_dropout
									A         =					layer_norm_eps
									A         =					hidden_act



		@classmethod
		def 					A_		( cls  :    int      ,							snake_case  :    Union[str, os.PathLike]      ,							**snake_case  :    Optional[int]				)			->						"PretrainedConfig":






									'''simple docstring'''

									cls._set_token_in_kwargs(snake_case				)

									A      ,  A         =					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":
																A         =					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      UpperCAmelCase__		(      UpperCamelCase     ):
		lowerCAmelCase_       :	List[Any] 							=     """git"""



		def __init__( self  :    Optional[Any]      ,							snake_case  :    Optional[int]=None      ,							snake_case  :    Dict=30_522      ,							snake_case  :    int=768      ,							snake_case  :    str=6      ,							snake_case  :    Tuple=12      ,							snake_case  :    List[str]=3_072      ,							snake_case  :    str="gelu"      ,							snake_case  :    Dict=0.1      ,							snake_case  :    Tuple=0.1      ,							snake_case  :    Dict=1_024      ,							snake_case  :    Any=0.02      ,							snake_case  :    List[str]=1E-1_2      ,							snake_case  :    List[Any]=0      ,							snake_case  :    Tuple="absolute"      ,							snake_case  :    Tuple=True      ,							snake_case  :    Dict=False      ,							snake_case  :    int=101      ,							snake_case  :    int=102      ,							snake_case  :    List[Any]=None      ,							**snake_case  :    Union[str, Any]      ,							)			->						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:
																A         =					{}
																logger.info('vision_config is None. initializing the GitVisionConfig with default values.'				)

									A         =					GitVisionConfig(**snake_case				)
									A         =					vocab_size
									A         =					hidden_size
									A         =					num_hidden_layers
									A         =					num_attention_heads
									A         =					hidden_act
									A         =					intermediate_size
									A         =					hidden_dropout_prob
									A         =					attention_probs_dropout_prob
									A         =					max_position_embeddings
									A         =					initializer_range
									A         =					layer_norm_eps
									A         =					position_embedding_type
									A         =					use_cache
									A         =					tie_word_embeddings
									A         =					num_image_with_embedding

									A         =					bos_token_id
									A         =					eos_token_id



		def 					A_		( self  :    int				)			->						Dict:






									'''simple docstring'''

									A         =					copy.deepcopy(self.__dict__				)
									A         =					self.vision_config.to_dict()
									A         =					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    =			['bert-base-uncased', 'bert-base-cased']
A    =			'hf-internal-testing/tiny-bert-tf-only'

if is_tf_available():






							class      UpperCAmelCase__		(      tf.keras.Model     ):



									def __init__( self  :    Tuple      ,							snake_case  :    Optional[int]				)			->						List[str]:






																'''simple docstring'''

																super().__init__()
																A         =					tokenizer
																A         =					AutoConfig.from_pretrained(snake_case				)
																A         =					TFAutoModel.from_config(snake_case				)



									def 					A_		( self  :    Any      ,							snake_case  :    Optional[int]				)			->						Dict:






																'''simple docstring'''

																A         =					self.tokenizer(snake_case				)
																A         =					self.bert(**snake_case				)
																return out["pooler_output"]






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



		def 					A_		( self  :    int				)			->						Tuple:






									'''simple docstring'''

									super().setUp()

									A         =					[
									    BertTokenizer.from_pretrained(snake_case				) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
									]  # repeat for when fast_bert_tokenizer=false
									A         =					[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				)

									A         =					[
									    '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ċ, ꝼ',
									]
									A         =					list(zip(self.test_sentences      ,							self.test_sentences[::-1]				)				)



		def 					A_		( self  :    List[Any]				)			->						Dict:






									'''simple docstring'''

									for tokenizer, tf_tokenizer in zip(self.tokenizers      ,							self.tf_tokenizers				):
																for test_inputs in (self.test_sentences, self.paired_sentences):
																							A         =					tokenizer(snake_case      ,							return_tensors='tf'      ,							padding='longest'				)
																							A         =					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 					A_		( self  :    Tuple				)			->						Tuple:






									'''simple docstring'''

									for tf_tokenizer in self.tf_tokenizers:
																A         =					tf_tokenizer(self.paired_sentences				)
																A         =					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 					A_		( self  :    Any				)			->						Tuple:






									'''simple docstring'''

									for tf_tokenizer in self.tf_tokenizers:
																A         =					tf.function(snake_case				)
																for test_inputs in (self.test_sentences, self.paired_sentences):
																							A         =					tf.constant(snake_case				)
																							A         =					compiled_tokenizer(snake_case				)
																							A         =					tf_tokenizer(snake_case				)

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



		@slow
		def 					A_		( self  :    Optional[Any]				)			->						Optional[Any]:






									'''simple docstring'''

									for tf_tokenizer in self.tf_tokenizers:
																A         =					ModelToSave(tokenizer=snake_case				)
																A         =					tf.convert_to_tensor(self.test_sentences				)
																A         =					model(snake_case				)  # Build model with some sample inputs
																with TemporaryDirectory() as tempdir:
																							A         =					Path(snake_case				) / 'saved.model'
																							model.save(snake_case				)
																							A         =					tf.keras.models.load_model(snake_case				)
																A         =					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				)



