






"""simple docstring"""







import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
	import torch

	from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin







class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							def __init__(   self:     List[str]				,		__A:     Optional[int]				,		__A:     Dict=None				,		__A:     str=None				,		__A:     Any=None				,		__A:     Optional[Any]="resnet50"				,		__A:     Any=3				,		__A:     Union[str, Any]=32				,		__A:     Optional[int]=3				,		__A:     Any=True				,		__A:     str=True				,		):

												'''simple docstring'''

												a__          =  parent
												a__          =  out_indices if out_indices is not None else [4]
												a__          =  stage_names
												a__          =  out_features
												a__          =  backbone
												a__          =  batch_size
												a__          =  image_size
												a__          =  num_channels
												a__          =  use_pretrained_backbone
												a__          =  is_training




							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )
												a__          =  self.get_config()

												return config, pixel_values




							def  lowercase		(   self:     Any    ):

												'''simple docstring'''

												return TimmBackboneConfig(
												    image_size=self.image_size				,		num_channels=self.num_channels				,		out_features=self.out_features				,		out_indices=self.out_indices				,		stage_names=self.stage_names				,		use_pretrained_backbone=self.use_pretrained_backbone				,		backbone=self.backbone				,		)




							def  lowercase		(   self:     Dict				,		__A:     int				,		__A:     Dict    ):

												'''simple docstring'''

												a__          =  TimmBackbone(config=__A    )
												model.to(__A    )
												model.eval()
												with torch.no_grad():
																	a__          =  model(__A    )
												self.parent.assertEqual(
												    result.feature_map[-1].shape				,		(self.batch_size, model.channels[-1], 14, 14)				,		)





							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  self.prepare_config_and_inputs()
												a__       ,a__          =  config_and_inputs
												a__          =  {'''pixel_values''': pixel_values}
												return config, inputs_dict







@require_torch
@require_timm
class        _SCREAMING_SNAKE_CASE						(  __snake_case       , __snake_case       , __snake_case       , unittest.TestCase							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =(TimmBackbone,) if is_torch_available() else ()
							_SCREAMING_SNAKE_CASE    ={'feature-extraction': TimmBackbone} if is_torch_available() else {}
							_SCREAMING_SNAKE_CASE    =False
							_SCREAMING_SNAKE_CASE    =False
							_SCREAMING_SNAKE_CASE    =False
							_SCREAMING_SNAKE_CASE    =False




							def  lowercase		(   self:     List[Any]    ):

												'''simple docstring'''

												a__          =  TimmBackboneModelTester(self    )
												a__          =  ConfigTester(self				,		config_class=__A				,		has_text_modality=__A    )




							def  lowercase		(   self:     str    ):

												'''simple docstring'''

												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()




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

												'''simple docstring'''

												a__          =  '''resnet18'''
												a__          =  '''microsoft/resnet-18'''

												a__          =  AutoBackbone.from_pretrained(__A				,		use_timm_backbone=__A    )
												a__          =  AutoBackbone.from_pretrained(__A    )

												self.assertEqual(len(timm_model.out_features    )				,		len(transformers_model.out_features    )    )
												self.assertEqual(len(timm_model.stage_names    )				,		len(transformers_model.stage_names    )    )
												self.assertEqual(timm_model.channels				,		transformers_model.channels    )
												# Out indices are set to the last layer by default. For timm models, we don't know
												# the number of layers in advance, so we set it to (-1,), whereas for transformers
												# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
												self.assertEqual(timm_model.out_indices				,		(-1,)    )
												self.assertEqual(transformers_model.out_indices				,		[len(timm_model.stage_names    ) - 1]    )

												a__          =  AutoBackbone.from_pretrained(__A				,		use_timm_backbone=__A				,		out_indices=[1, 2, 3]    )
												a__          =  AutoBackbone.from_pretrained(__A				,		out_indices=[1, 2, 3]    )

												self.assertEqual(timm_model.out_indices				,		transformers_model.out_indices    )
												self.assertEqual(len(timm_model.out_features    )				,		len(transformers_model.out_features    )    )
												self.assertEqual(timm_model.channels				,		transformers_model.channels    )




							@unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''    )
							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												pass




							@unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''    )
							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												pass




							@unittest.skip('''TimmBackbone initialization is managed on the timm side'''    )
							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												pass




							@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''    )
							def  lowercase		(   self:     List[Any]    ):

												'''simple docstring'''

												pass




							@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''    )
							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												pass




							@unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''    )
							def  lowercase		(   self:     Any    ):

												'''simple docstring'''

												pass




							@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''    )
							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												pass




							@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''    )
							def  lowercase		(   self:     List[Any]    ):

												'''simple docstring'''

												pass




							@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''    )
							def  lowercase		(   self:     Union[str, Any]    ):

												'''simple docstring'''

												pass




							@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''    )
							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

												pass




							@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''    )
							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												pass




							@unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''    )
							def  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

												pass




							@unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''    )
							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												pass




							@unittest.skip('''Safetensors is not supported by timm.'''    )
							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												pass




							@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''    )
							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												pass




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

												'''simple docstring'''

												a__       ,a__          =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	a__          =  model_class(__A    )
																	a__          =  inspect.signature(model.forward    )
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	a__          =  [*signature.parameters.keys()]

																	a__          =  ['''pixel_values''']
																	self.assertListEqual(arg_names[:1]				,		__A    )




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

												'''simple docstring'''

												a__       ,a__          =  self.model_tester.prepare_config_and_inputs_for_common()
												a__          =  True
												a__          =  self.has_attentions

												# no need to test all models as different heads yield the same functionality
												a__          =  self.all_model_classes[0]
												a__          =  model_class(__A    )
												model.to(__A    )

												a__          =  self._prepare_for_class(__A				,		__A    )
												a__          =  model(**__A    )
												a__          =  outputs[0][-1]

												# Encoder-/Decoder-only models
												a__          =  outputs.hidden_states[0]
												hidden_states.retain_grad()

												if self.has_attentions:
																	a__          =  outputs.attentions[0]
																	attentions.retain_grad()

												output.flatten()[0].backward(retain_graph=__A    )

												self.assertIsNotNone(hidden_states.grad    )

												if self.has_attentions:
																	self.assertIsNotNone(attentions.grad    )





							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__       ,a__          =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	a__          =  model_class(__A    )
																	model.to(__A    )
																	model.eval()
																	a__          =  model(**__A    )

																	self.assertEqual(len(result.feature_maps    )				,		len(config.out_indices    )    )
																	self.assertEqual(len(model.channels    )				,		len(config.out_indices    )    )

																	# Check output of last stage is taken if out_features=None, out_indices=None
																	a__          =  copy.deepcopy(__A    )
																	a__          =  None
																	a__          =  model_class(__A    )
																	model.to(__A    )
																	model.eval()
																	a__          =  model(**__A    )

																	self.assertEqual(len(result.feature_maps    )				,		1    )
																	self.assertEqual(len(model.channels    )				,		1    )

																	# Check backbone can be initialized with fresh weights
																	a__          =  copy.deepcopy(__A    )
																	a__          =  False
																	a__          =  model_class(__A    )
																	model.to(__A    )
																	model.eval()
																	a__          =  model(**__A    )










"""simple docstring"""







import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402


__a       :	Dict             = {
    'return_dict': False,
    'output_hidden_states': True,
    'output_attentions': True,
    'torchscript': True,
    'torch_dtype': 'float16',
    'use_bfloat16': True,
    'tf_legacy_loss': True,
    'pruned_heads': {'a': 1},
    'tie_word_embeddings': False,
    'is_decoder': True,
    'cross_attention_hidden_size': 128,
    'add_cross_attention': True,
    'tie_encoder_decoder': True,
    'max_length': 50,
    'min_length': 3,
    'do_sample': True,
    'early_stopping': True,
    'num_beams': 3,
    'num_beam_groups': 3,
    'diversity_penalty': 0.5,
    'temperature': 2.0,
    'top_k': 10,
    'top_p': 0.7,
    'typical_p': 0.2,
    'repetition_penalty': 0.8,
    'length_penalty': 0.8,
    'no_repeat_ngram_size': 5,
    'encoder_no_repeat_ngram_size': 5,
    'bad_words_ids': [1, 2, 3],
    'num_return_sequences': 3,
    'chunk_size_feed_forward': 5,
    'output_scores': True,
    'return_dict_in_generate': True,
    'forced_bos_token_id': 2,
    'forced_eos_token_id': 3,
    'remove_invalid_values': True,
    'architectures': ['BertModel'],
    'finetuning_task': 'translation',
    'id2label': {0: 'label'},
    'label2id': {'label': '0'},
    'tokenizer_class': 'BertTokenizerFast',
    'prefix': 'prefix',
    'bos_token_id': 6,
    'pad_token_id': 7,
    'eos_token_id': 8,
    'sep_token_id': 9,
    'decoder_start_token_id': 10,
    'exponential_decay_length_penalty': (5, 1.01),
    'suppress_tokens': [0, 1],
    'begin_suppress_tokens': 2,
    'task_specific_params': {'translation': 'some_params'},
    'problem_type': 'regression',
}







@is_staging_test
class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							@classmethod
							def  lowercase		(   cls:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  TOKEN
												HfFolder.save_token(__A    )




							@classmethod
							def  lowercase		(   cls:     Any    ):

												'''simple docstring'''

												try:
																	delete_repo(token=cls._token				,		repo_id='''test-config'''    )
												except HTTPError:
																	pass

												try:
																	delete_repo(token=cls._token				,		repo_id='''valid_org/test-config-org'''    )
												except HTTPError:
																	pass

												try:
																	delete_repo(token=cls._token				,		repo_id='''test-dynamic-config'''    )
												except HTTPError:
																	pass




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

												'''simple docstring'''

												a__          =  BertConfig(
												    vocab_size=99				,		hidden_size=32				,		num_hidden_layers=5				,		num_attention_heads=4				,		intermediate_size=37    )
												config.push_to_hub('''test-config'''				,		use_auth_token=self._token    )

												a__          =  BertConfig.from_pretrained(F'{USER}/test-config'    )
												for k, v in config.to_dict().items():
																	if k != "transformers_version":
																						self.assertEqual(__A				,		getattr(__A				,		__A    )    )

        # Reset repo
												delete_repo(token=self._token				,		repo_id='''test-config'''    )

												# Push to hub via save_pretrained
												with tempfile.TemporaryDirectory() as tmp_dir:
																	config.save_pretrained(__A				,		repo_id='''test-config'''				,		push_to_hub=__A				,		use_auth_token=self._token    )

												a__          =  BertConfig.from_pretrained(F'{USER}/test-config'    )
												for k, v in config.to_dict().items():
																	if k != "transformers_version":
																						self.assertEqual(__A				,		getattr(__A				,		__A    )    )




							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  BertConfig(
												    vocab_size=99				,		hidden_size=32				,		num_hidden_layers=5				,		num_attention_heads=4				,		intermediate_size=37    )
												config.push_to_hub('''valid_org/test-config-org'''				,		use_auth_token=self._token    )

												a__          =  BertConfig.from_pretrained('''valid_org/test-config-org'''    )
												for k, v in config.to_dict().items():
																	if k != "transformers_version":
																						self.assertEqual(__A				,		getattr(__A				,		__A    )    )

        # Reset repo
												delete_repo(token=self._token				,		repo_id='''valid_org/test-config-org'''    )

												# Push to hub via save_pretrained
												with tempfile.TemporaryDirectory() as tmp_dir:
																	config.save_pretrained(
																	    __A				,		repo_id='''valid_org/test-config-org'''				,		push_to_hub=__A				,		use_auth_token=self._token    )

												a__          =  BertConfig.from_pretrained('''valid_org/test-config-org'''    )
												for k, v in config.to_dict().items():
																	if k != "transformers_version":
																						self.assertEqual(__A				,		getattr(__A				,		__A    )    )





							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												CustomConfig.register_for_auto_class()
												a__          =  CustomConfig(attribute=42    )

												config.push_to_hub('''test-dynamic-config'''				,		use_auth_token=self._token    )

												# This has added the proper auto_map field to the config
												self.assertDictEqual(config.auto_map				,		{'''AutoConfig''': '''custom_configuration.CustomConfig'''}    )

												a__          =  AutoConfig.from_pretrained(F'{USER}/test-dynamic-config'				,		trust_remote_code=__A    )
												# Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
												self.assertEqual(new_config.__class__.__name__				,		'''CustomConfig'''    )
												self.assertEqual(new_config.attribute				,		42    )







class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												a__          =  GPTaConfig()

												# attempt to modify each of int/float/bool/str config records and verify they were updated
												a__          =  c.n_embd + 1  # int
												a__          =  c.resid_pdrop + 1.0  # float
												a__          =  not c.scale_attn_weights  # bool
												a__          =  c.summary_type + '''foo'''  # str
												c.update_from_string(
												    F'n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'    )
												self.assertEqual(__A				,		c.n_embd				,		'''mismatch for key: n_embd'''    )
												self.assertEqual(__A				,		c.resid_pdrop				,		'''mismatch for key: resid_pdrop'''    )
												self.assertEqual(__A				,		c.scale_attn_weights				,		'''mismatch for key: scale_attn_weights'''    )
												self.assertEqual(__A				,		c.summary_type				,		'''mismatch for key: summary_type'''    )




							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  PretrainedConfig()
												a__          =  [key for key in base_config.__dict__ if key not in config_common_kwargs]
												# If this part of the test fails, you have arguments to addin config_common_kwargs above.
												self.assertListEqual(
												    __A				,		['''is_encoder_decoder''', '''_name_or_path''', '''_commit_hash''', '''transformers_version''']    )
												a__          =  [key for key, value in config_common_kwargs.items() if value == getattr(__A				,		__A    )]
												if len(__A    ) > 0:
																	raise ValueError(
																	    '''The following keys are set with the default values in'''
																	    ''' `test_configuration_common.config_common_kwargs` pick another value for them:'''
																	    F' {", ".join(__A    )}.'    )




							def  lowercase		(   self:     str    ):

												'''simple docstring'''

												with self.assertRaises(__A    ):
																	# config is in subfolder, the following should not work without specifying the subfolder
																	a__          =  BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''    )

												a__          =  BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''				,		subfolder='''bert'''    )

												self.assertIsNotNone(__A    )




							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

												a__          =  mock.Mock()
												a__          =  500
												a__          =  {}
												a__          =  HTTPError
												a__          =  {}

												# Download this model to make sure it's in the cache.
												a__          =  BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )

												# Under the mock environment we get a 500 error when trying to reach the model.
												with mock.patch('''requests.Session.request'''				,		return_value=__A    ) as mock_head:
																	a__          =  BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )
																	# This check we did call the fake head request
																	mock_head.assert_called()




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

												'''simple docstring'''

												a__          =  BertConfig.from_pretrained(
												    '''https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'''    )




							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  AutoConfig.from_pretrained('''bert-base-cased'''    )
												a__          =  ['''config.4.0.0.json''']

												with tempfile.TemporaryDirectory() as tmp_dir:
																	configuration.save_pretrained(__A    )
																	a__          =  2
																	json.dump(configuration.to_dict()				,		open(os.path.join(__A				,		'''config.4.0.0.json'''    )				,		'''w'''    )    )

																	# This should pick the new configuration file as the version of Transformers is > 4.0.0
																	a__          =  AutoConfig.from_pretrained(__A    )
																	self.assertEqual(new_configuration.hidden_size				,		2    )

																	# Will need to be adjusted if we reach v42 and this test is still here.
																	# Should pick the old configuration file as the version of Transformers is < 4.42.0
																	a__          =  ['''config.42.0.0.json''']
																	a__          =  768
																	configuration.save_pretrained(__A    )
																	shutil.move(os.path.join(__A				,		'''config.4.0.0.json'''    )				,		os.path.join(__A				,		'''config.42.0.0.json'''    )    )
																	a__          =  AutoConfig.from_pretrained(__A    )
																	self.assertEqual(new_configuration.hidden_size				,		768    )





							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  '''hf-internal-testing/test-two-configs'''

												import transformers as new_transformers

												a__          =  '''v4.0.0'''
												a__       ,a__          =  new_transformers.models.auto.AutoConfig.from_pretrained(
												    __A				,		return_unused_kwargs=__A    )
												self.assertEqual(new_configuration.hidden_size				,		2    )
												# This checks `_configuration_file` ia not kept in the kwargs by mistake.
												self.assertDictEqual(__A				,		{}    )

												# Testing an older version by monkey-patching the version in the module it's used.
												import transformers as old_transformers

												a__          =  '''v3.0.0'''
												a__          =  old_transformers.models.auto.AutoConfig.from_pretrained(__A    )
												self.assertEqual(old_configuration.hidden_size				,		768    )


