






import argparse
import json
import pickle
from pathlib import Path

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

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase__							=     logging.get_logger(__name__)






def   UpperCamelCase  (       snake_case__     :   str  ):




     '''simple docstring'''






     __snake_case			:Any          =						SwinConfig.from_pretrained(
         """microsoft/swin-tiny-patch4-window7-224"""	,out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]  )
     __snake_case			:int          =						MaskFormerConfig(backbone_config=snake_case__  )

     __snake_case			:Union[str, Any]          =						"""huggingface/label-files"""
     if "ade20k-full" in model_name:
          # this should be ok
          __snake_case			:Dict          =						847
          __snake_case			:Union[str, Any]          =						"""maskformer-ade20k-full-id2label.json"""
     elif "ade" in model_name:
          # this should be ok
          __snake_case			:Dict          =						150
          __snake_case			:Union[str, Any]          =						"""ade20k-id2label.json"""
     elif "coco-stuff" in model_name:
          # this should be ok
          __snake_case			:int          =						171
          __snake_case			:Optional[int]          =						"""maskformer-coco-stuff-id2label.json"""
     elif "coco" in model_name:
          # TODO
          __snake_case			:str          =						133
          __snake_case			:str          =						"""coco-panoptic-id2label.json"""
     elif "cityscapes" in model_name:
          # this should be ok
          __snake_case			:Optional[Any]          =						19
          __snake_case			:str          =						"""cityscapes-id2label.json"""
     elif "vistas" in model_name:
          # this should be ok
          __snake_case			:str          =						65
          __snake_case			:List[Any]          =						"""mapillary-vistas-id2label.json"""

     __snake_case			:str          =						json.load(open(hf_hub_download(snake_case__	,snake_case__	,repo_type="""dataset"""  )	,"""r"""  )  )
     __snake_case			:Any          =						{int(snake_case__  ): v for k, v in idalabel.items()}

     return config






def   UpperCamelCase  (       snake_case__     :   Optional[int]  ):




     '''simple docstring'''






     __snake_case			:Tuple          =						[]
     # stem
     # fmt: off
     rename_keys.append(("""backbone.patch_embed.proj.weight""", """model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight""")  )
     rename_keys.append(("""backbone.patch_embed.proj.bias""", """model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias""")  )
     rename_keys.append(("""backbone.patch_embed.norm.weight""", """model.pixel_level_module.encoder.model.embeddings.norm.weight""")  )
     rename_keys.append(("""backbone.patch_embed.norm.bias""", """model.pixel_level_module.encoder.model.embeddings.norm.bias""")  )
     # stages
     for i in range(len(config.backbone_config.depths  )  ):
          for j in range(config.backbone_config.depths[i]  ):
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm1.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm1.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.relative_position_index''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.proj.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.proj.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm2.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm2.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc1.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc1.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc2.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight''')  )
               rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc2.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias''')  )

          if i < 3:
               rename_keys.append((f'''backbone.layers.{i}.downsample.reduction.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight''')  )
               rename_keys.append((f'''backbone.layers.{i}.downsample.norm.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight''')  )
               rename_keys.append((f'''backbone.layers.{i}.downsample.norm.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias''')  )
          rename_keys.append((f'''backbone.norm{i}.weight''', f'''model.pixel_level_module.encoder.hidden_states_norms.{i}.weight''')  )
          rename_keys.append((f'''backbone.norm{i}.bias''', f'''model.pixel_level_module.encoder.hidden_states_norms.{i}.bias''')  )

     # FPN
     rename_keys.append(("""sem_seg_head.layer_4.weight""", """model.pixel_level_module.decoder.fpn.stem.0.weight""")  )
     rename_keys.append(("""sem_seg_head.layer_4.norm.weight""", """model.pixel_level_module.decoder.fpn.stem.1.weight""")  )
     rename_keys.append(("""sem_seg_head.layer_4.norm.bias""", """model.pixel_level_module.decoder.fpn.stem.1.bias""")  )
     for source_index, target_index in zip(range(3	,0	,-1  )	,range(0	,3  )  ):
          rename_keys.append((f'''sem_seg_head.adapter_{source_index}.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight''')  )
          rename_keys.append((f'''sem_seg_head.adapter_{source_index}.norm.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight''')  )
          rename_keys.append((f'''sem_seg_head.adapter_{source_index}.norm.bias''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias''')  )
          rename_keys.append((f'''sem_seg_head.layer_{source_index}.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight''')  )
          rename_keys.append((f'''sem_seg_head.layer_{source_index}.norm.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight''')  )
          rename_keys.append((f'''sem_seg_head.layer_{source_index}.norm.bias''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias''')  )
     rename_keys.append(("""sem_seg_head.mask_features.weight""", """model.pixel_level_module.decoder.mask_projection.weight""")  )
     rename_keys.append(("""sem_seg_head.mask_features.bias""", """model.pixel_level_module.decoder.mask_projection.bias""")  )

     # Transformer decoder
     for idx in range(config.decoder_config.decoder_layers  ):
          # self-attention out projection
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight''', f'''model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias''', f'''model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias''')  )
          # cross-attention out projection
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias''')  )
          # MLP 1
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight''', f'''model.transformer_module.decoder.layers.{idx}.fc1.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias''', f'''model.transformer_module.decoder.layers.{idx}.fc1.bias''')  )
          # MLP 2
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight''', f'''model.transformer_module.decoder.layers.{idx}.fc2.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias''', f'''model.transformer_module.decoder.layers.{idx}.fc2.bias''')  )
          # layernorm 1 (self-attention layernorm)
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight''', f'''model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias''', f'''model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias''')  )
          # layernorm 2 (cross-attention layernorm)
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias''')  )
          # layernorm 3 (final layernorm)
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight''', f'''model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias''', f'''model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias''')  )

     rename_keys.append(("""sem_seg_head.predictor.transformer.decoder.norm.weight""", """model.transformer_module.decoder.layernorm.weight""")  )
     rename_keys.append(("""sem_seg_head.predictor.transformer.decoder.norm.bias""", """model.transformer_module.decoder.layernorm.bias""")  )

     # heads on top
     rename_keys.append(("""sem_seg_head.predictor.query_embed.weight""", """model.transformer_module.queries_embedder.weight""")  )

     rename_keys.append(("""sem_seg_head.predictor.input_proj.weight""", """model.transformer_module.input_projection.weight""")  )
     rename_keys.append(("""sem_seg_head.predictor.input_proj.bias""", """model.transformer_module.input_projection.bias""")  )

     rename_keys.append(("""sem_seg_head.predictor.class_embed.weight""", """class_predictor.weight""")  )
     rename_keys.append(("""sem_seg_head.predictor.class_embed.bias""", """class_predictor.bias""")  )

     for i in range(3  ):
          rename_keys.append((f'''sem_seg_head.predictor.mask_embed.layers.{i}.weight''', f'''mask_embedder.{i}.0.weight''')  )
          rename_keys.append((f'''sem_seg_head.predictor.mask_embed.layers.{i}.bias''', f'''mask_embedder.{i}.0.bias''')  )
     # fmt: on

     return rename_keys






def   UpperCamelCase  (       snake_case__     :   Dict	,snake_case__     :   List[str]	,snake_case__     :   Union[str, Any]  ):




     '''simple docstring'''






     __snake_case			:List[Any]          =						dct.pop(snake_case__  )
     __snake_case			:Union[str, Any]          =						val






def   UpperCamelCase  (       snake_case__     :   Union[str, Any]	,snake_case__     :   Dict  ):




     '''simple docstring'''






     __snake_case			:Union[str, Any]          =						[int(backbone_config.embed_dim * 2**i  ) for i in range(len(backbone_config.depths  )  )]
     for i in range(len(backbone_config.depths  )  ):
          __snake_case			:int          =						num_features[i]
          for j in range(backbone_config.depths[i]  ):
               # fmt: off
               # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
               __snake_case			:str          =						state_dict.pop(f'''backbone.layers.{i}.blocks.{j}.attn.qkv.weight'''  )
               __snake_case			:Any          =						state_dict.pop(f'''backbone.layers.{i}.blocks.{j}.attn.qkv.bias'''  )
               # next, add query, keys and values (in that order) to the state dict
               __snake_case			:Union[str, Any]          =						in_proj_weight[:dim, :]
               __snake_case			:List[Any]          =						in_proj_bias[: dim]
               __snake_case			:int          =						in_proj_weight[
                   dim : dim * 2, :
               ]
               __snake_case			:List[Any]          =						in_proj_bias[
                   dim : dim * 2
               ]
               __snake_case			:Any          =						in_proj_weight[
                   -dim :, :
               ]
               __snake_case			:List[Any]          =						in_proj_bias[-dim :]
               # fmt: on






def   UpperCamelCase  (       snake_case__     :   str	,snake_case__     :   Optional[int]  ):




     '''simple docstring'''






     __snake_case			:Dict          =						config.decoder_config.hidden_size
     for idx in range(config.decoder_config.decoder_layers  ):
          # read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
          __snake_case			:Dict          =						state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight'''  )
          __snake_case			:List[str]          =						state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias'''  )
          # next, add query, keys and values (in that order) to the state dict
          __snake_case			:Tuple          =						in_proj_weight[: hidden_size, :]
          __snake_case			:str          =						in_proj_bias[:config.hidden_size]
          __snake_case			:Optional[int]          =						in_proj_weight[hidden_size : hidden_size * 2, :]
          __snake_case			:Optional[int]          =						in_proj_bias[hidden_size : hidden_size * 2]
          __snake_case			:str          =						in_proj_weight[-hidden_size :, :]
          __snake_case			:Tuple          =						in_proj_bias[-hidden_size :]
          # read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
          __snake_case			:int          =						state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight'''  )
          __snake_case			:Optional[int]          =						state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias'''  )
          # next, add query, keys and values (in that order) to the state dict
          __snake_case			:int          =						in_proj_weight[: hidden_size, :]
          __snake_case			:Any          =						in_proj_bias[:config.hidden_size]
          __snake_case			:List[str]          =						in_proj_weight[hidden_size : hidden_size * 2, :]
          __snake_case			:Tuple          =						in_proj_bias[hidden_size : hidden_size * 2]
          __snake_case			:int          =						in_proj_weight[-hidden_size :, :]
          __snake_case			:int          =						in_proj_bias[-hidden_size :]
     # fmt: on






def   UpperCamelCase  (       ):




     '''simple docstring'''






     __snake_case			:Union[str, Any]          =						"""http://images.cocodataset.org/val2017/000000039769.jpg"""
     __snake_case			:Optional[int]          =						Image.open(requests.get(snake_case__	,stream=snake_case__  ).raw  )
     return im






@torch.no_grad()
def   UpperCamelCase  (       snake_case__     :   str	,snake_case__     :   str	,snake_case__     :   str	,snake_case__     :   bool = False  ):




     '''simple docstring'''






     __snake_case			:str          =						get_maskformer_config(snake_case__  )

     # load original state_dict
     with open(snake_case__	,"""rb"""  ) as f:
          __snake_case			:str          =						pickle.load(snake_case__  )
     __snake_case			:int          =						data["""model"""]

     # for name, param in state_dict.items():
     #     print(name, param.shape)

     # rename keys
     __snake_case			:str          =						create_rename_keys(snake_case__  )
     for src, dest in rename_keys:
          rename_key(snake_case__	,snake_case__	,snake_case__  )
     read_in_swin_q_k_v(snake_case__	,config.backbone_config  )
     read_in_decoder_q_k_v(snake_case__	,snake_case__  )

     # update to torch tensors
     for key, value in state_dict.items():
          __snake_case			:Tuple          =						torch.from_numpy(snake_case__  )

     # load 🤗 model
     __snake_case			:int          =						MaskFormerForInstanceSegmentation(snake_case__  )
     model.eval()

     for name, param in model.named_parameters():
          print(snake_case__	,param.shape  )

     __snake_case			:Any          =						model.load_state_dict(snake_case__	,strict=snake_case__  )
     assert missing_keys == [
         "model.pixel_level_module.encoder.model.layernorm.weight",
         "model.pixel_level_module.encoder.model.layernorm.bias",
     ]
     assert len(snake_case__  ) == 0, f'''Unexpected keys: {unexpected_keys}'''

     # verify results
     __snake_case			:Optional[int]          =						prepare_img()
     if "vistas" in model_name:
          __snake_case			:List[str]          =						65
     elif "cityscapes" in model_name:
          __snake_case			:Optional[Any]          =						6_5535
     else:
          __snake_case			:Optional[Any]          =						255
     __snake_case			:Union[str, Any]          =						True if """ade""" in model_name else False
     __snake_case			:List[Any]          =						MaskFormerImageProcessor(ignore_index=snake_case__	,reduce_labels=snake_case__  )

     __snake_case			:int          =						image_processor(snake_case__	,return_tensors="""pt"""  )

     __snake_case			:Tuple          =						model(**snake_case__  )

     print("""Logits:"""	,outputs.class_queries_logits[0, :3, :3]  )

     if model_name == "maskformer-swin-tiny-ade":
          __snake_case			:Optional[Any]          =						torch.tensor(
              [[3.6_3_5_3, -4.4_7_7_0, -2.6_0_6_5], [0.5_0_8_1, -4.2_3_9_4, -3.5_3_4_3], [2.1_9_0_9, -5.0_3_5_3, -1.9_3_2_3]]  )
     assert torch.allclose(outputs.class_queries_logits[0, :3, :3]	,snake_case__	,atol=1e-4  )
     print("""Looks ok!"""  )

     if pytorch_dump_folder_path is not None:
          print(f'''Saving model and image processor to {pytorch_dump_folder_path}'''  )
          Path(snake_case__  ).mkdir(exist_ok=snake_case__  )
          model.save_pretrained(snake_case__  )
          image_processor.save_pretrained(snake_case__  )

     if push_to_hub:
          print("""Pushing model and image processor to the hub..."""  )
          model.push_to_hub(f'''nielsr/{model_name}'''  )
          image_processor.push_to_hub(f'''nielsr/{model_name}'''  )


if __name__ == "__main__":
     lowerCamelCase__							=     argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         """--model_name""",
         default="""maskformer-swin-tiny-ade""",
         type=str,
         help=("""Name of the MaskFormer model you'd like to convert""",),
     )
     parser.add_argument(
         """--checkpoint_path""",
         default="""/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl""",
         type=str,
         help="""Path to the original state dict (.pth file).""",
     )
     parser.add_argument(
         """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
     )
     parser.add_argument(
         """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
     )

     lowerCamelCase__							=     parser.parse_args()
     convert_maskformer_checkpoint(
         args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
     )









import copy
import os
from typing import TYPE_CHECKING, List, Union


if TYPE_CHECKING:
     pass

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


lowerCamelCase__							=     logging.get_logger(__name__)

lowerCamelCase__							=     {
    """kakaobrain/align-base""": """https://huggingface.co/kakaobrain/align-base/resolve/main/config.json""",
}




class 			snake_case__   (							lowercase_):

       '''simple docstring'''
       lowerCamelCase							:				Union[str, Any] 				= "align_text_model"



       def __init__(							self			,						a__=3_05_22			,						a__=7_68			,						a__=12			,						a__=12			,						a__=30_72			,						a__="gelu"			,						a__=0.1			,						a__=0.1			,						a__=5_12			,						a__=2			,						a__=0.02			,						a__=1e-12			,						a__=0			,						a__="absolute"			,						a__=True			,						**a__			,						) ->      List[str]:






            '''simple docstring'''





            super().__init__(**a__    )

            __snake_case			:Optional[int]          =						vocab_size
            __snake_case			:List[str]          =						hidden_size
            __snake_case			:Optional[Any]          =						num_hidden_layers
            __snake_case			:int          =						num_attention_heads
            __snake_case			:Optional[Any]          =						hidden_act
            __snake_case			:Union[str, Any]          =						intermediate_size
            __snake_case			:int          =						hidden_dropout_prob
            __snake_case			:Optional[Any]          =						attention_probs_dropout_prob
            __snake_case			:List[str]          =						max_position_embeddings
            __snake_case			:List[str]          =						type_vocab_size
            __snake_case			:Union[str, Any]          =						initializer_range
            __snake_case			:str          =						layer_norm_eps
            __snake_case			:Any          =						position_embedding_type
            __snake_case			:List[str]          =						use_cache
            __snake_case			:Optional[int]          =						pad_token_id



       @classmethod
       def 					__lowercase						(							cls			,						a__			,						**a__    ) ->      "PretrainedConfig":






            '''simple docstring'''





            cls._set_token_in_kwargs(a__    )

            __snake_case       , __snake_case			:Tuple          =						cls.get_config_dict(a__			,						**a__    )

            # get the text config dict if we are loading from AlignConfig
            if config_dict.get("""model_type"""    ) == "align":
                 __snake_case			:Any          =						config_dict["""text_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(a__			,						**a__    )




class 			snake_case__   (							lowercase_):

       '''simple docstring'''
       lowerCamelCase							:				Optional[int] 				= "align_vision_model"



       def __init__(							self			,						a__ = 3			,						a__ = 6_00			,						a__ = 2.0			,						a__ = 3.1			,						a__ = 8			,						a__ = [3, 3, 5, 3, 5, 5, 3]			,						a__ = [32, 16, 24, 40, 80, 1_12, 1_92]			,						a__ = [16, 24, 40, 80, 1_12, 1_92, 3_20]			,						a__ = []			,						a__ = [1, 2, 2, 2, 1, 2, 1]			,						a__ = [1, 2, 2, 3, 3, 4, 1]			,						a__ = [1, 6, 6, 6, 6, 6, 6]			,						a__ = 0.25			,						a__ = "swish"			,						a__ = 25_60			,						a__ = "mean"			,						a__ = 0.02			,						a__ = 0.0_01			,						a__ = 0.99			,						a__ = 0.2			,						**a__			,						) ->      List[Any]:






            '''simple docstring'''





            super().__init__(**a__    )

            __snake_case			:Union[str, Any]          =						num_channels
            __snake_case			:List[str]          =						image_size
            __snake_case			:int          =						width_coefficient
            __snake_case			:int          =						depth_coefficient
            __snake_case			:List[Any]          =						depth_divisor
            __snake_case			:Any          =						kernel_sizes
            __snake_case			:Optional[int]          =						in_channels
            __snake_case			:Optional[int]          =						out_channels
            __snake_case			:int          =						depthwise_padding
            __snake_case			:List[str]          =						strides
            __snake_case			:Union[str, Any]          =						num_block_repeats
            __snake_case			:Dict          =						expand_ratios
            __snake_case			:Union[str, Any]          =						squeeze_expansion_ratio
            __snake_case			:Any          =						hidden_act
            __snake_case			:Optional[Any]          =						hidden_dim
            __snake_case			:Union[str, Any]          =						pooling_type
            __snake_case			:Union[str, Any]          =						initializer_range
            __snake_case			:Optional[Any]          =						batch_norm_eps
            __snake_case			:List[Any]          =						batch_norm_momentum
            __snake_case			:Optional[int]          =						drop_connect_rate
            __snake_case			:Union[str, Any]          =						sum(a__    ) * 4



       @classmethod
       def 					__lowercase						(							cls			,						a__			,						**a__    ) ->      "PretrainedConfig":






            '''simple docstring'''





            cls._set_token_in_kwargs(a__    )

            __snake_case       , __snake_case			:int          =						cls.get_config_dict(a__			,						**a__    )

            # get the vision config dict if we are loading from AlignConfig
            if config_dict.get("""model_type"""    ) == "align":
                 __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(a__			,						**a__    )




class 			snake_case__   (							lowercase_):

       '''simple docstring'''
       lowerCamelCase							:				str 				= "align"
       lowerCamelCase							:				Union[str, Any] 				= True



       def __init__(							self			,						a__=None			,						a__=None			,						a__=6_40			,						a__=1.0			,						a__=0.02			,						**a__			,						) ->      Dict:






            '''simple docstring'''





            super().__init__(**a__    )

            if text_config is None:
                 __snake_case			:Union[str, Any]          =						{}
                 logger.info("""text_config is None. Initializing the AlignTextConfig with default values."""    )

            if vision_config is None:
                 __snake_case			:str          =						{}
                 logger.info("""vision_config is None. Initializing the AlignVisionConfig with default values."""    )

            __snake_case			:List[Any]          =						AlignTextConfig(**a__    )
            __snake_case			:Tuple          =						AlignVisionConfig(**a__    )

            __snake_case			:Tuple          =						projection_dim
            __snake_case			:int          =						temperature_init_value
            __snake_case			:Any          =						initializer_range



       @classmethod
       def 					__lowercase						(							cls			,						a__			,						a__			,						**a__    ) ->      str:






            '''simple docstring'''





            return cls(text_config=text_config.to_dict()			,						vision_config=vision_config.to_dict()			,						**a__    )



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Optional[Any]          =						copy.deepcopy(self.__dict__    )
            __snake_case			:Dict          =						self.text_config.to_dict()
            __snake_case			:Union[str, Any]          =						self.vision_config.to_dict()
            __snake_case			:List[Any]          =						self.__class__.model_type
            return output


