


"""simple docstring"""







import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BertTokenizer,
    ViltConfig,
    ViltForImageAndTextRetrieval,
    ViltForImagesAndTextClassification,
    ViltForMaskedLM,
    ViltForQuestionAnswering,
    ViltImageProcessor,
    ViltProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
a__							:				Union[str, Any]          =	logging.get_logger(__name__)




def   UpperCAmelCase__			(lowerCAmelCase_    ,		lowerCAmelCase_=False    ,		lowerCAmelCase_=False    ,		lowerCAmelCase_=False  ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE		  =							[]
					for i in range(config.num_hidden_layers  ):
										# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
										rename_keys.append((f"""transformer.blocks.{i}.norm1.weight""", f"""vilt.encoder.layer.{i}.layernorm_before.weight""")  )
										rename_keys.append((f"""transformer.blocks.{i}.norm1.bias""", f"""vilt.encoder.layer.{i}.layernorm_before.bias""")  )
										rename_keys.append(
										    (f"""transformer.blocks.{i}.attn.proj.weight""", f"""vilt.encoder.layer.{i}.attention.output.dense.weight""")  )
										rename_keys.append(
										    (f"""transformer.blocks.{i}.attn.proj.bias""", f"""vilt.encoder.layer.{i}.attention.output.dense.bias""")  )
										rename_keys.append((f"""transformer.blocks.{i}.norm2.weight""", f"""vilt.encoder.layer.{i}.layernorm_after.weight""")  )
										rename_keys.append((f"""transformer.blocks.{i}.norm2.bias""", f"""vilt.encoder.layer.{i}.layernorm_after.bias""")  )
										rename_keys.append(
										    (f"""transformer.blocks.{i}.mlp.fc1.weight""", f"""vilt.encoder.layer.{i}.intermediate.dense.weight""")  )
										rename_keys.append((f"""transformer.blocks.{i}.mlp.fc1.bias""", f"""vilt.encoder.layer.{i}.intermediate.dense.bias""")  )
										rename_keys.append((f"""transformer.blocks.{i}.mlp.fc2.weight""", f"""vilt.encoder.layer.{i}.output.dense.weight""")  )
										rename_keys.append((f"""transformer.blocks.{i}.mlp.fc2.bias""", f"""vilt.encoder.layer.{i}.output.dense.bias""")  )

					# embeddings
					rename_keys.extend(
					    [
					        # text embeddings
					        ("text_embeddings.word_embeddings.weight", "vilt.embeddings.text_embeddings.word_embeddings.weight"),
					        (
					            "text_embeddings.position_embeddings.weight",
					            "vilt.embeddings.text_embeddings.position_embeddings.weight",
					        ),
					        ("text_embeddings.position_ids", "vilt.embeddings.text_embeddings.position_ids"),
					        (
					            "text_embeddings.token_type_embeddings.weight",
					            "vilt.embeddings.text_embeddings.token_type_embeddings.weight",
					        ),
					        ("text_embeddings.LayerNorm.weight", "vilt.embeddings.text_embeddings.LayerNorm.weight"),
					        ("text_embeddings.LayerNorm.bias", "vilt.embeddings.text_embeddings.LayerNorm.bias"),
					        # patch embeddings
					        ("transformer.cls_token", "vilt.embeddings.cls_token"),
					        ("transformer.patch_embed.proj.weight", "vilt.embeddings.patch_embeddings.projection.weight"),
					        ("transformer.patch_embed.proj.bias", "vilt.embeddings.patch_embeddings.projection.bias"),
					        ("transformer.pos_embed", "vilt.embeddings.position_embeddings"),
					        # token type embeddings
					        ("token_type_embeddings.weight", "vilt.embeddings.token_type_embeddings.weight"),
					    ]  )

					# final layernorm + pooler
					rename_keys.extend(
					    [
					        ("transformer.norm.weight", "vilt.layernorm.weight"),
					        ("transformer.norm.bias", "vilt.layernorm.bias"),
					        ("pooler.dense.weight", "vilt.pooler.dense.weight"),
					        ("pooler.dense.bias", "vilt.pooler.dense.bias"),
					    ]  )

					# classifier head(s)
					if vqa_model:
										# classification head
										rename_keys.extend(
										    [
										        ("vqa_classifier.0.weight", "classifier.0.weight"),
										        ("vqa_classifier.0.bias", "classifier.0.bias"),
										        ("vqa_classifier.1.weight", "classifier.1.weight"),
										        ("vqa_classifier.1.bias", "classifier.1.bias"),
										        ("vqa_classifier.3.weight", "classifier.3.weight"),
										        ("vqa_classifier.3.bias", "classifier.3.bias"),
										    ]  )
					elif nlvr_model:
										# classification head
										rename_keys.extend(
										    [
										        ("nlvr2_classifier.0.weight", "classifier.0.weight"),
										        ("nlvr2_classifier.0.bias", "classifier.0.bias"),
										        ("nlvr2_classifier.1.weight", "classifier.1.weight"),
										        ("nlvr2_classifier.1.bias", "classifier.1.bias"),
										        ("nlvr2_classifier.3.weight", "classifier.3.weight"),
										        ("nlvr2_classifier.3.bias", "classifier.3.bias"),
										    ]  )
					else:
										pass

					return rename_keys




def   UpperCAmelCase__			(lowerCAmelCase_    ,		lowerCAmelCase_  ):




					'''simple docstring'''


					for i in range(config.num_hidden_layers  ):
										__SCREAMING_SNAKE_CASE		  =							"vilt."
										# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
										__SCREAMING_SNAKE_CASE		  =							state_dict.pop(f"""transformer.blocks.{i}.attn.qkv.weight"""  )
										__SCREAMING_SNAKE_CASE		  =							state_dict.pop(f"""transformer.blocks.{i}.attn.qkv.bias"""  )
										# next, add query, keys and values (in that order) to the state dict
										__SCREAMING_SNAKE_CASE		  =							in_proj_weight[
										    : config.hidden_size, :
										]
										__SCREAMING_SNAKE_CASE		  =							in_proj_bias[: config.hidden_size]
										__SCREAMING_SNAKE_CASE		  =							in_proj_weight[
										    config.hidden_size : config.hidden_size * 2, :
										]
										__SCREAMING_SNAKE_CASE		  =							in_proj_bias[
										    config.hidden_size : config.hidden_size * 2
										]
										__SCREAMING_SNAKE_CASE		  =							in_proj_weight[
										    -config.hidden_size :, :
										]
										__SCREAMING_SNAKE_CASE		  =							in_proj_bias[-config.hidden_size :]




def   UpperCAmelCase__			(lowerCAmelCase_  ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE		  =							["head.weight", "head.bias"]
					for k in ignore_keys:
										state_dict.pop(__lowerCAmelCase    ,		__lowerCAmelCase  )




def   UpperCAmelCase__			(lowerCAmelCase_    ,		lowerCAmelCase_    ,		lowerCAmelCase_  ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE		  =							dct.pop(__lowerCAmelCase  )
					__SCREAMING_SNAKE_CASE		  =							val




@torch.no_grad()
def   UpperCAmelCase__			(lowerCAmelCase_    ,		lowerCAmelCase_  ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE		  =							ViltConfig(image_size=384    ,		patch_size=32    ,		tie_word_embeddings=__lowerCAmelCase  )
					__SCREAMING_SNAKE_CASE		  =							False
					__SCREAMING_SNAKE_CASE		  =							False
					__SCREAMING_SNAKE_CASE		  =							False
					__SCREAMING_SNAKE_CASE		  =							False
					if "vqa" in checkpoint_url:
										__SCREAMING_SNAKE_CASE		  =							True
										__SCREAMING_SNAKE_CASE		  =							3129
										__SCREAMING_SNAKE_CASE		  =							"huggingface/label-files"
										__SCREAMING_SNAKE_CASE		  =							"vqa2-id2label.json"
										__SCREAMING_SNAKE_CASE		  =							json.load(open(hf_hub_download(__lowerCAmelCase    ,		__lowerCAmelCase    ,		repo_type="dataset"  )    ,		"r"  )  )
										__SCREAMING_SNAKE_CASE		  =							{int(__lowerCAmelCase  ): v for k, v in idalabel.items()}
										__SCREAMING_SNAKE_CASE		  =							idalabel
										__SCREAMING_SNAKE_CASE		  =							{v: k for k, v in idalabel.items()}
										__SCREAMING_SNAKE_CASE		  =							ViltForQuestionAnswering(__lowerCAmelCase  )
					elif "nlvr" in checkpoint_url:
										__SCREAMING_SNAKE_CASE		  =							True
										__SCREAMING_SNAKE_CASE		  =							2
										__SCREAMING_SNAKE_CASE		  =							{0: "False", 1: "True"}
										__SCREAMING_SNAKE_CASE		  =							{v: k for k, v in config.idalabel.items()}
										__SCREAMING_SNAKE_CASE		  =							3
										__SCREAMING_SNAKE_CASE		  =							ViltForImagesAndTextClassification(__lowerCAmelCase  )
					elif "irtr" in checkpoint_url:
										__SCREAMING_SNAKE_CASE		  =							True
										__SCREAMING_SNAKE_CASE		  =							ViltForImageAndTextRetrieval(__lowerCAmelCase  )
					elif "mlm_itm" in checkpoint_url:
										__SCREAMING_SNAKE_CASE		  =							True
										__SCREAMING_SNAKE_CASE		  =							ViltForMaskedLM(__lowerCAmelCase  )
					else:
										raise ValueError("Unknown model type"  )

					# load state_dict of original model, remove and rename some keys
					__SCREAMING_SNAKE_CASE		  =							torch.hub.load_state_dict_from_url(__lowerCAmelCase    ,		map_location="cpu"  )["state_dict"]
					__SCREAMING_SNAKE_CASE		  =							create_rename_keys(__lowerCAmelCase    ,		__lowerCAmelCase    ,		__lowerCAmelCase    ,		__lowerCAmelCase  )
					for src, dest in rename_keys:
										rename_key(__lowerCAmelCase    ,		__lowerCAmelCase    ,		__lowerCAmelCase  )
					read_in_q_k_v(__lowerCAmelCase    ,		__lowerCAmelCase  )
					if mlm_model or irtr_model:
										__SCREAMING_SNAKE_CASE		  =							["itm_score.fc.weight", "itm_score.fc.bias"]
										for k in ignore_keys:
															state_dict.pop(__lowerCAmelCase    ,		__lowerCAmelCase  )

    # load state dict into HuggingFace model
					model.eval()
					if mlm_model:
										__SCREAMING_SNAKE_CASE  ,    __SCREAMING_SNAKE_CASE		  =							model.load_state_dict(__lowerCAmelCase    ,		strict=__lowerCAmelCase  )
										assert missing_keys == ["mlm_score.decoder.bias"]
					else:
										model.load_state_dict(__lowerCAmelCase  )

					# Define processor
					__SCREAMING_SNAKE_CASE		  =							ViltImageProcessor(size=384  )
					__SCREAMING_SNAKE_CASE		  =							BertTokenizer.from_pretrained("bert-base-uncased"  )
					__SCREAMING_SNAKE_CASE		  =							ViltProcessor(__lowerCAmelCase    ,		__lowerCAmelCase  )

					# Forward pass on example inputs (image + text)
					if nlvr_model:
										__SCREAMING_SNAKE_CASE		  =							Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg"    ,		stream=__lowerCAmelCase  ).raw  )
										__SCREAMING_SNAKE_CASE		  =							Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg"    ,		stream=__lowerCAmelCase  ).raw  )
										__SCREAMING_SNAKE_CASE		  =							(
										    "The left image contains twice the number of dogs as the right image, and at least two dogs in total are"
										    " standing."
										)
										__SCREAMING_SNAKE_CASE		  =							processor(__lowerCAmelCase    ,		__lowerCAmelCase    ,		return_tensors="pt"  )
										__SCREAMING_SNAKE_CASE		  =							processor(__lowerCAmelCase    ,		__lowerCAmelCase    ,		return_tensors="pt"  )
										__SCREAMING_SNAKE_CASE		  =							model(
										    input_ids=encoding_a.input_ids    ,		pixel_values=encoding_a.pixel_values    ,		pixel_values_a=encoding_a.pixel_values    ,		)
					else:
										__SCREAMING_SNAKE_CASE		  =							Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg"    ,		stream=__lowerCAmelCase  ).raw  )
										if mlm_model:
															__SCREAMING_SNAKE_CASE		  =							"a bunch of [MASK] laying on a [MASK]."
										else:
															__SCREAMING_SNAKE_CASE		  =							"How many cats are there?"
										__SCREAMING_SNAKE_CASE		  =							processor(__lowerCAmelCase    ,		__lowerCAmelCase    ,		return_tensors="pt"  )
										__SCREAMING_SNAKE_CASE		  =							model(**__lowerCAmelCase  )

					# Verify outputs
					if mlm_model:
										__SCREAMING_SNAKE_CASE		  =							torch.Size([1, 11, 3_0522]  )
										__SCREAMING_SNAKE_CASE		  =							torch.tensor([-12.5061, -12.5123, -12.5174]  )
										assert outputs.logits.shape == expected_shape
										assert torch.allclose(outputs.logits[0, 0, :3]    ,		__lowerCAmelCase    ,		atol=1E-4  )

										# verify masked token prediction equals "cats"
										__SCREAMING_SNAKE_CASE		  =							outputs.logits[0, 4, :].argmax(-1  ).item()
										assert tokenizer.decode([predicted_id]  ) == "cats"
					elif vqa_model:
										__SCREAMING_SNAKE_CASE		  =							torch.Size([1, 3129]  )
										__SCREAMING_SNAKE_CASE		  =							torch.tensor([-15.9495, -18.1472, -10.3041]  )
										assert torch.allclose(outputs.logits[0, :3]    ,		__lowerCAmelCase    ,		atol=1E-4  )
										assert outputs.logits.shape == expected_shape
										assert torch.allclose(outputs.logits[0, 0, :3]    ,		__lowerCAmelCase    ,		atol=1E-4  )

										# verify vqa prediction equals "2"
										__SCREAMING_SNAKE_CASE		  =							outputs.logits.argmax(-1  ).item()
										assert model.config.idalabel[predicted_idx] == "2"
					elif nlvr_model:
										__SCREAMING_SNAKE_CASE		  =							torch.Size([1, 2]  )
										__SCREAMING_SNAKE_CASE		  =							torch.tensor([-2.8721, 2.1291]  )
										assert torch.allclose(outputs.logits[0, :3]    ,		__lowerCAmelCase    ,		atol=1E-4  )
										assert outputs.logits.shape == expected_shape

					Path(__lowerCAmelCase  ).mkdir(exist_ok=__lowerCAmelCase  )
					print(f"""Saving model and processor to {pytorch_dump_folder_path}"""  )
					model.save_pretrained(__lowerCAmelCase  )
					processor.save_pretrained(__lowerCAmelCase  )


if __name__ == "__main__":
		a__							:				Tuple          =	argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--checkpoint_url''',
		    default='''https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt''',
		    type=str,
		    help='''URL of the checkpoint you\'d like to convert.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
		)

		a__							:				int          =	parser.parse_args()
		convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)







'''simple docstring'''




import inspect
import os
import re

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
_SCREAMING_SNAKE_CASE							     =			"src/transformers"


# This is to make sure the transformers module imported is the one in the repo.
_SCREAMING_SNAKE_CASE							     =			direct_transformers_import(PATH_TO_TRANSFORMERS)

_SCREAMING_SNAKE_CASE							     =			transformers.models.auto.configuration_auto.CONFIG_MAPPING

_SCREAMING_SNAKE_CASE							     =			{
    # used to compute the property `self.chunk_length`
    "EncodecConfig": ["overlap"],
    # used as `self.bert_model = BertModel(config, ...)`
    "DPRConfig": True,
    # not used in modeling files, but it's an important information
    "FSMTConfig": ["langs"],
    # used internally in the configuration class file
    "GPTNeoConfig": ["attention_types"],
    # used internally in the configuration class file
    "EsmConfig": ["is_folding_model"],
    # used during training (despite we don't have training script for these models yet)
    "Mask2FormerConfig": ["ignore_value"],
    # `ignore_value` used during training (despite we don't have training script for these models yet)
    # `norm` used in conversion script (despite not using in the modeling file)
    "OneFormerConfig": ["ignore_value", "norm"],
    # used during preprocessing and collation, see `collating_graphormer.py`
    "GraphormerConfig": ["spatial_pos_max"],
    # used internally in the configuration class file
    "T5Config": ["feed_forward_proj"],
    # used internally in the configuration class file
    # `tokenizer_class` get default value `T5Tokenizer` intentionally
    "MT5Config": ["feed_forward_proj", "tokenizer_class"],
    "UMT5Config": ["feed_forward_proj", "tokenizer_class"],
    # used internally in the configuration class file
    "LongT5Config": ["feed_forward_proj"],
    # used internally in the configuration class file
    "SwitchTransformersConfig": ["feed_forward_proj"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "BioGptConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "GLPNConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "SegformerConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "CvtConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "PerceiverConfig": ["layer_norm_eps"],
    # used internally to calculate the feature size
    "InformerConfig": ["num_static_real_features", "num_time_features"],
    # used internally to calculate the feature size
    "TimeSeriesTransformerConfig": ["num_static_real_features", "num_time_features"],
    # used internally to calculate the feature size
    "AutoformerConfig": ["num_static_real_features", "num_time_features"],
    # used internally to calculate `mlp_dim`
    "SamVisionConfig": ["mlp_ratio"],
    # For (head) training, but so far not implemented
    "ClapAudioConfig": ["num_classes"],
    # Not used, but providing useful information to users
    "SpeechT5HifiGanConfig": ["sampling_rate"],
}


# TODO (ydshieh): Check the failing cases, try to fix them or move some cases to the above block once we are sure
SPECIAL_CASES_TO_ALLOW.update(
    {
        "CLIPSegConfig": True,
        "DeformableDetrConfig": True,
        "DetaConfig": True,
        "DinatConfig": True,
        "DonutSwinConfig": True,
        "EfficientFormerConfig": True,
        "FSMTConfig": True,
        "JukeboxConfig": True,
        "LayoutLMv2Config": True,
        "MaskFormerSwinConfig": True,
        "MT5Config": True,
        "NatConfig": True,
        "OneFormerConfig": True,
        "PerceiverConfig": True,
        "RagConfig": True,
        "SpeechT5Config": True,
        "SwinConfig": True,
        "Swin2SRConfig": True,
        "Swinv2Config": True,
        "SwitchTransformersConfig": True,
        "TableTransformerConfig": True,
        "TapasConfig": True,
        "TransfoXLConfig": True,
        "UniSpeechConfig": True,
        "UniSpeechSatConfig": True,
        "WavLMConfig": True,
        "WhisperConfig": True,
        # TODO: @Arthur (for `alignment_head` and `alignment_layer`)
        "JukeboxPriorConfig": True,
        # TODO: @Younes (for `is_decoder`)
        "Pix2StructTextConfig": True,
    }
)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							Any      ,    __lowerCAmelCase       :							Dict      ,    __lowerCAmelCase       :							List[str]      ,    __lowerCAmelCase       :							Union[str, Any]		)		->  List[Any]:
   snake_case 						=   False
   for attribute in attributes:
      for modeling_source in source_strings:
         # check if we can find `config.xxx`, `getattr(config, "xxx", ...)` or `getattr(self.config, "xxx", ...)`
         if (
             F'''config.{attribute}''' in modeling_source
             or F'''getattr(config, "{attribute}"''' in modeling_source
             or F'''getattr(self.config, "{attribute}"''' in modeling_source
         ):
            snake_case 						=   True
         # Deal with multi-line cases
         elif (
             re.search(
                 rF'''getattr[ \t\v\n\r\f]*\([ \t\v\n\r\f]*(self\.)?config,[ \t\v\n\r\f]*"{attribute}"'''      ,    __lowerCAmelCase      ,    )
             is not None
         ):
            snake_case 						=   True
         # `SequenceSummary` is called with `SequenceSummary(config)`
         elif attribute in [
             "summary_type",
             "summary_use_proj",
             "summary_activation",
             "summary_last_dropout",
             "summary_proj_to_labels",
             "summary_first_dropout",
         ]:
            if "SequenceSummary" in modeling_source:
               snake_case 						=   True
         if attribute_used:
            break
      if attribute_used:
         break

    # common and important attributes, even if they do not always appear in the modeling files
   snake_case 						=   [
       """bos_index""",
       """eos_index""",
       """pad_index""",
       """unk_index""",
       """mask_index""",
       """image_size""",
       """use_cache""",
       """out_features""",
       """out_indices""",
   ]
   snake_case 						=   ["""encoder_no_repeat_ngram_size"""]

   # Special cases to be allowed
   snake_case 						=   True
   if not attribute_used:
      snake_case 						=   False
      for attribute in attributes:
         # Allow if the default value in the configuration class is different from the one in `PretrainedConfig`
         if attribute in ["is_encoder_decoder"] and default_value is True:
            snake_case 						=   True
         elif attribute in ["tie_word_embeddings"] and default_value is False:
            snake_case 						=   True

         # Allow cases without checking the default value in the configuration class
         elif attribute in attributes_to_allow + attributes_used_in_generation:
            snake_case 						=   True
         elif attribute.endswith("""_token_id"""		):
            snake_case 						=   True

         # configuration class specific cases
         if not case_allowed:
            snake_case 						=   SPECIAL_CASES_TO_ALLOW.get(config_class.__name__      ,    []		)
            snake_case 						=   allowed_cases is True or attribute in allowed_cases

   return attribute_used or case_allowed





def 	__lowerCamelCase			(      __lowerCAmelCase       :							Union[str, Any]		)		->  List[Any]:
   snake_case 						=   dict(inspect.signature(config_class.__init__		).parameters		)
   snake_case 						=   [x for x in list(signature.keys()		) if x not in ["""self""", """kwargs"""]]
   snake_case 						=   [signature[param].default for param in parameter_names]

   # If `attribute_map` exists, an attribute can have different names to be used in the modeling files, and as long
   # as one variant is used, the test should pass
   snake_case 						=   {}
   if len(config_class.attribute_map		) > 0:
      snake_case 						=   {v: k for k, v in config_class.attribute_map.items()}

   # Get the path to modeling source files
   snake_case 						=   inspect.getsourcefile(__lowerCAmelCase		)
   snake_case 						=   os.path.dirname(__lowerCAmelCase		)
   # Let's check against all frameworks: as long as one framework uses an attribute, we are good.
   snake_case 						=   [os.path.join(__lowerCAmelCase      ,    __lowerCAmelCase		) for fn in os.listdir(__lowerCAmelCase		) if fn.startswith("""modeling_"""		)]

   # Get the source code strings
   snake_case 						=   []
   for path in modeling_paths:
      if os.path.isfile(__lowerCAmelCase		):
         with open(__lowerCAmelCase		) as fp:
            modeling_sources.append(fp.read()		)

   snake_case 						=   []
   for config_param, default_value in zip(__lowerCAmelCase      ,    __lowerCAmelCase		):
      # `attributes` here is all the variant names for `config_param`
      snake_case 						=   [config_param]
      # some configuration classes have non-empty `attribute_map`, and both names could be used in the
      # corresponding modeling files. As long as one of them appears, it is fine.
      if config_param in reversed_attribute_map:
         attributes.append(reversed_attribute_map[config_param]		)

      if not check_attribute_being_used(__lowerCAmelCase      ,    __lowerCAmelCase      ,    __lowerCAmelCase      ,    __lowerCAmelCase		):
         unused_attributes.append(attributes[0]		)

   return sorted(__lowerCAmelCase		)





def 	__lowerCamelCase			(      )		->  Optional[Any]:
   snake_case 						=   {}
   for _config_class in list(CONFIG_MAPPING.values()		):
      # Skip deprecated models
      if "models.deprecated" in _config_class.__module__:
         continue
      # Some config classes are not in `CONFIG_MAPPING` (e.g. `CLIPVisionConfig`, `Blip2VisionConfig`, etc.)
      snake_case 						=   [
          cls
          for name, cls in inspect.getmembers(
              inspect.getmodule(_config_class		)      ,    lambda __lowerCAmelCase		: inspect.isclass(__lowerCAmelCase		)
              and issubclass(__lowerCAmelCase      ,    __lowerCAmelCase		)
              and inspect.getmodule(__lowerCAmelCase		) == inspect.getmodule(_config_class		)      ,    )
      ]
      for config_class in config_classes_in_module:
         snake_case 						=   check_config_attributes_being_used(__lowerCAmelCase		)
         if len(__lowerCAmelCase		) > 0:
            snake_case 						=   unused_attributes

   if len(__lowerCAmelCase		) > 0:
      snake_case 						=   """The following configuration classes contain unused attributes in the corresponding modeling files:\n"""
      for name, attributes in configs_with_unused_attributes.items():
         error += F'''{name}: {attributes}\n'''

      raise ValueError(__lowerCAmelCase		)


if __name__ == "__main__":
 check_config_attributes()

