






import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis_float32 (there's also the fix_lavis branch)
# also note: to convert Vicuna checkpoints, we had to include /home/niels/python_projects/checkpoints/FastChat/vicuna-7b in lavis/configs/models/blip2/blip2_instruct_vicuna7b.yaml
# same for Vicuna-13b
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipImageProcessor,
    InstructBlipConfig,
    InstructBlipForConditionalGeneration,
    InstructBlipProcessor,
    InstructBlipQFormerConfig,
    InstructBlipVisionConfig,
    LlamaConfig,
    LlamaTokenizerFast,
    TaConfig,
    TaTokenizerFast,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD

def      lowerCAmelCase__	(    ):
		snake_case_				:							str						 =       "https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg"
		snake_case_				:							Tuple						 =       Image.open(requests.get(_a  ,      stream=_a    ).raw    ).convert("RGB"    )

		return image

def      lowerCAmelCase__	(    _a       :			Optional[int]    ):
		snake_case_				:							Optional[int]						 =       []
		# fmt: off

		# vision encoder
		rename_keys.append(("visual_encoder.cls_token", "vision_model.embeddings.class_embedding")    )
		rename_keys.append(("visual_encoder.pos_embed", "vision_model.embeddings.position_embedding")    )
		rename_keys.append(("visual_encoder.patch_embed.proj.weight", "vision_model.embeddings.patch_embedding.weight")    )
		rename_keys.append(("visual_encoder.patch_embed.proj.bias", "vision_model.embeddings.patch_embedding.bias")    )
		rename_keys.append(("ln_vision.weight", "vision_model.post_layernorm.weight")    )
		rename_keys.append(("ln_vision.bias", "vision_model.post_layernorm.bias")    )

		for i in range(config.vision_config.num_hidden_layers    ):
				rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.weight''', F'''vision_model.encoder.layers.{i}.layer_norm1.weight''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.bias''', F'''vision_model.encoder.layers.{i}.layer_norm1.bias''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.weight''', F'''vision_model.encoder.layers.{i}.layer_norm2.weight''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.bias''', F'''vision_model.encoder.layers.{i}.layer_norm2.bias''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.attn.qkv.weight''', F'''vision_model.encoder.layers.{i}.self_attn.qkv.weight''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.weight''', F'''vision_model.encoder.layers.{i}.self_attn.projection.weight''',)    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.bias''', F'''vision_model.encoder.layers.{i}.self_attn.projection.bias''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc1.weight''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc1.bias''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc2.weight''')    )
				rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc2.bias''')    )

		# QFormer
		rename_keys.append(("Qformer.bert.embeddings.LayerNorm.weight", "qformer.embeddings.layernorm.weight")    )
		rename_keys.append(("Qformer.bert.embeddings.LayerNorm.bias", "qformer.embeddings.layernorm.bias")    )

		# fmt: on
		return rename_keys

def      lowerCAmelCase__	(    _a       :			List[Any]  ,      _a       :			str  ,      _a       :			List[Any]    ):
		snake_case_				:							Optional[int]						 =       dct.pop(_a    )
		snake_case_				:							Tuple						 =       val

def      lowerCAmelCase__	(    _a       :			Union[str, Any]  ,      _a       :			Optional[int]    ):
		for i in range(config.vision_config.num_hidden_layers    ):
				# read in original q and v biases
				snake_case_				:							List[Any]						 =       state_dict.pop(F'''visual_encoder.blocks.{i}.attn.q_bias'''    )
				snake_case_				:							Union[str, Any]						 =       state_dict.pop(F'''visual_encoder.blocks.{i}.attn.v_bias'''    )

				# next, set bias in the state dict
				snake_case_				:							List[Any]						 =       torch.cat((q_bias, torch.zeros_like(_a  ,      requires_grad=_a    ), v_bias)    )
				snake_case_				:							List[Any]						 =       qkv_bias

def      lowerCAmelCase__	(    _a       :			Any    ):
		snake_case_				:							Optional[int]						 =       3_64 if "coco" in model_name else 2_24
		snake_case_				:							Any						 =       InstructBlipVisionConfig(image_size=_a    ).to_dict()

		# make sure the models have proper bos_token_id and eos_token_id set (important for generation)
		# seems like flan-T5 models don't have bos_token_id properly set?
		if "t5-xl" in model_name:
				snake_case_				:							List[str]						 =       TaConfig.from_pretrained("google/flan-t5-xl"  ,      dense_act_fn="gelu"  ,      bos_token_id=1    ).to_dict()
		elif "t5-xxl" in model_name:
				snake_case_				:							Optional[int]						 =       TaConfig.from_pretrained("google/flan-t5-xxl"  ,      dense_act_fn="gelu"  ,      bos_token_id=1    ).to_dict()
		elif "vicuna-7b" in model_name:
				snake_case_				:							Optional[Any]						 =       LlamaConfig.from_pretrained("decapoda-research/llama-7b-hf"  ,      vocab_size=3_20_01    ).to_dict()
		elif "vicuna-13b" in model_name:
				snake_case_				:							Optional[Any]						 =       LlamaConfig.from_pretrained("decapoda-research/llama-13b-hf"  ,      vocab_size=3_20_01    ).to_dict()
		else:
				raise ValueError("Model name not supported"    )

		# the authors add one special "[DEC]" token to the vocab of Q-Former, hence vocab size = 30522 + 1
		snake_case_				:							int						 =       InstructBlipQFormerConfig(vocab_size=3_05_23    ).to_dict()
		snake_case_				:							Optional[int]						 =       InstructBlipConfig(vision_config=_a  ,      text_config=_a  ,      qformer_config=_a    )

		return config, image_size

@torch.no_grad()
def      lowerCAmelCase__	(    _a       :			Union[str, Any]  ,      _a       :			List[str]=None  ,      _a       :			List[Any]=False    ):
		snake_case_				:							List[Any]						 =       AutoTokenizer.from_pretrained("bert-base-uncased"  ,      truncation_side="left"    )
		qformer_tokenizer.add_special_tokens({"bos_token": "[DEC]"}    )

		if "t5" in model_name:
				snake_case_				:							Any						 =       TaTokenizerFast.from_pretrained("google/flan-t5-xl"  ,      truncation_side="left"    )
		elif "vicuna" in model_name:
				# the following was used in the original implementation:
				# tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", use_fast=False, truncation_side="left")
				# tokenizer.add_special_tokens({"pad_token": "[PAD]"})
				# tokenizer.add_special_tokens({"bos_token": "</s>"})
				# tokenizer.add_special_tokens({"eos_token": "</s>"})
				# tokenizer.add_special_tokens({"unk_token": "</s>"})
				snake_case_				:							str						 =       LlamaTokenizerFast.from_pretrained(
				    "huggyllama/llama-7b"  ,      truncation_side="left"  ,      bos_token="</s>"  ,      unk_token="</s>"    )
				tokenizer.add_special_tokens({"pad_token": "[PAD]"}    )

		snake_case_				:							List[str]						 =       get_blipa_config(_a    )
		snake_case_				:							str						 =       InstructBlipForConditionalGeneration(_a    ).eval()

		snake_case_				:							List[Any]						 =       {
		    "instructblip-vicuna-7b": ("blip2_vicuna_instruct", "vicuna7b"),
		    "instructblip-vicuna-13b": ("blip2_vicuna_instruct", "vicuna13b"),
		    "instructblip-flan-t5-xl": ("blip2_t5_instruct", "flant5xl"),
		    "instructblip-flan-t5-xxl": ("blip2_t5_instruct", "flant5xxl"),
		}

		snake_case_				:							List[Any]						 =       model_name_to_original[model_name]

		# load original model
		print("Loading original model..."    )
		snake_case_				:							Optional[Any]						 =       "cuda:1" if torch.cuda.is_available() else "cpu"
		snake_case_				:							Union[str, Any]						 =       "cuda:2" if torch.cuda.is_available() else "cpu"
		snake_case_				:							Any						 =       load_model_and_preprocess(
		    name=_a  ,      model_type=_a  ,      is_eval=_a  ,      device=_a    )
		original_model.eval()
		print("Done!"    )

		# update state dict keys
		snake_case_				:							Any						 =       original_model.state_dict()
		snake_case_				:							Union[str, Any]						 =       create_rename_keys(_a    )
		for src, dest in rename_keys:
				rename_key(_a  ,      _a  ,      _a    )

		# some keys can be renamed efficiently
		for key, val in state_dict.copy().items():
				snake_case_				:							int						 =       state_dict.pop(_a    )
				if key.startswith("Qformer.bert"    ):
						snake_case_				:							Dict						 =       key.replace("Qformer.bert"  ,      "qformer"    )
				if "attention.self" in key:
						snake_case_				:							List[Any]						 =       key.replace("self"  ,      "attention"    )
				if "llm_proj" in key:
						snake_case_				:							List[str]						 =       key.replace("llm_proj"  ,      "language_projection"    )
				if "t5_proj" in key:
						snake_case_				:							Any						 =       key.replace("t5_proj"  ,      "language_projection"    )
				if key.startswith("llm_model"    ):
						snake_case_				:							Optional[int]						 =       key.replace("llm_model"  ,      "language_model"    )
				if key.startswith("t5"    ):
						snake_case_				:							Tuple						 =       key.replace("t5"  ,      "language"    )
				snake_case_				:							List[Any]						 =       val

		# read in qv biases
		read_in_q_v_bias(_a  ,      _a    )

		# note: weights get loaded in torch.float32 by default
		hf_model.load_state_dict(_a  ,      strict=_a    )

		snake_case_				:							Optional[int]						 =       load_demo_image()
		snake_case_				:							Optional[Any]						 =       "What is unusual about this image?"

		# create processor
		snake_case_				:							str						 =       BlipImageProcessor(
		    size={"height": image_size, "width": image_size}  ,      image_mean=_a  ,      image_std=_a    )
		snake_case_				:							Dict						 =       InstructBlipProcessor(
		    image_processor=_a  ,      tokenizer=_a  ,      qformer_tokenizer=_a  ,      )
		snake_case_				:							Optional[int]						 =       processor(images=_a  ,      text=_a  ,      return_tensors="pt"    ).to(_a    )

		# make sure processor creates exact same pixel values
		snake_case_				:							Optional[int]						 =       vis_processors["eval"](_a    ).unsqueeze(0    ).to(_a    )
		snake_case_				:							Dict						 =       inputs.pixel_values
		assert torch.allclose(original_pixel_values.to(pixel_values.device    )  ,      _a    )

		original_model.to(_a    )
		hf_model.to(_a    )
		with torch.no_grad():
				if "vicuna" in model_name:
						snake_case_				:							Optional[Any]						 =       original_model({"image": original_pixel_values, "text_input": [prompt]}    ).logits
						snake_case_				:							Tuple						 =       hf_model(**_a    ).logits
				else:
						snake_case_				:							Any						 =       original_model(
						    {"image": original_pixel_values, "text_input": [prompt], "text_output": ["\n"]}    ).logits
						snake_case_				:							Union[str, Any]						 =       tokenizer("\n"  ,      return_tensors="pt"    ).input_ids.to(_a    )
						snake_case_				:							Union[str, Any]						 =       label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id  ,      -1_00    )
						snake_case_				:							Optional[int]						 =       hf_model(**_a  ,      labels=_a    ).logits

		print("First values of original logits:"  ,      original_logits[0, :3, :3]    )
		print("First values of HF logits:"  ,      logits[0, :3, :3]    )

		# assert values
		assert original_logits.shape == logits.shape
		snake_case_				:							Optional[Any]						 =       1E-4 if "vicuna" in model_name else 1E-5
		assert torch.allclose(original_logits.to(logits.device    )  ,      _a  ,      atol=_a    )
		print("Looks ok!"    )

		print("Generating with original model..."    )
		snake_case_				:							Dict						 =       original_model.generate({"image": original_pixel_values, "prompt": prompt}  ,      num_beams=5    )

		# important: we need to cast the weights of the HF model to the appropriate type
		print("Generating with HF model..."    )
		snake_case_				:							List[Any]						 =       hf_model.generate(
		    **_a  ,      do_sample=_a  ,      num_beams=5  ,      max_length=2_56  ,      min_length=1  ,      top_p=0.9  ,      repetition_penalty=1.5  ,      length_penalty=1.0  ,      temperature=1  ,      )
		if "vicuna" in model_name:
				# convert output id 0 to 2 (eos_token_id)
				# TODO add this in the generate method?
				snake_case_				:							Any						 =       2
		print("Original generation:"  ,      _a    )
		snake_case_				:							Dict						 =       processor.batch_decode(_a  ,      skip_special_tokens=_a    )
		snake_case_				:							Any						 =       [text.strip() for text in output_text]
		print("HF generation:"  ,      _a    )

		if pytorch_dump_folder_path is not None:
				processor.save_pretrained(_a    )
				hf_model.save_pretrained(_a    )

		if push_to_hub:
				processor.push_to_hub(F'''Salesforce/{model_name}'''    )
				hf_model.push_to_hub(F'''Salesforce/{model_name}'''    )


if __name__ == "__main__":
							lowercase  :							List[Any]			  =    argparse.ArgumentParser()
							lowercase  :							Any			  =    [
							    '''instructblip-vicuna-7b''',
							    '''instructblip-vicuna-13b''',
							    '''instructblip-flan-t5-xl''',
							    '''instructblip-flan-t5-xxl''',
							]
							parser.add_argument(
							    '''--model_name''',
							    default='''instructblip-flan-t5-xl''',
							    choices=choices,
							    type=str,
							    help='''Path to hf config.json of model to convert''',
							)
							parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
							parser.add_argument(
							    '''--push_to_hub''',
							    action='''store_true''',
							    help='''Whether to push the model and processor to the hub after converting''',
							)

							lowercase  :							Optional[Any]			  =    parser.parse_args()

							convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








import copy
import os
from typing import Union

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


lowercase  :							int			  =    logging.get_logger(__name__)

lowercase  :							Any			  =    {
    '''BAAI/AltCLIP''': '''https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json''',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}




class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




						A     :   int						=					'altclip_text_model'






						def __init__(	self		,				_SCREAMING_SNAKE_CASE=25_0002		,				_SCREAMING_SNAKE_CASE=1024		,				_SCREAMING_SNAKE_CASE=24		,				_SCREAMING_SNAKE_CASE=16		,				_SCREAMING_SNAKE_CASE=4096		,				_SCREAMING_SNAKE_CASE="gelu"		,				_SCREAMING_SNAKE_CASE=0.1		,				_SCREAMING_SNAKE_CASE=0.1		,				_SCREAMING_SNAKE_CASE=514		,				_SCREAMING_SNAKE_CASE=1		,				_SCREAMING_SNAKE_CASE=0.02		,				_SCREAMING_SNAKE_CASE=0.02		,				_SCREAMING_SNAKE_CASE=1e-05		,				_SCREAMING_SNAKE_CASE=1		,				_SCREAMING_SNAKE_CASE=0		,				_SCREAMING_SNAKE_CASE=2		,				_SCREAMING_SNAKE_CASE="absolute"		,				_SCREAMING_SNAKE_CASE=True		,				_SCREAMING_SNAKE_CASE=768		,				**_SCREAMING_SNAKE_CASE		,				) ->				List[str]:
								super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE		,				bos_token_id=_SCREAMING_SNAKE_CASE		,				eos_token_id=_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE				)

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




class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




						A     :   List[Any]						=					'altclip_vision_model'






						def __init__(	self		,				_SCREAMING_SNAKE_CASE=768		,				_SCREAMING_SNAKE_CASE=3072		,				_SCREAMING_SNAKE_CASE=512		,				_SCREAMING_SNAKE_CASE=12		,				_SCREAMING_SNAKE_CASE=12		,				_SCREAMING_SNAKE_CASE=3		,				_SCREAMING_SNAKE_CASE=224		,				_SCREAMING_SNAKE_CASE=32		,				_SCREAMING_SNAKE_CASE="quick_gelu"		,				_SCREAMING_SNAKE_CASE=1e-5		,				_SCREAMING_SNAKE_CASE=0.0		,				_SCREAMING_SNAKE_CASE=0.02		,				_SCREAMING_SNAKE_CASE=1.0		,				**_SCREAMING_SNAKE_CASE		,				) ->				Optional[Any]:
								super().__init__(**_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Tuple						 =       hidden_size
								snake_case_				:							Dict						 =       intermediate_size
								snake_case_				:							Optional[int]						 =       projection_dim
								snake_case_				:							int						 =       num_hidden_layers
								snake_case_				:							Union[str, Any]						 =       num_attention_heads
								snake_case_				:							int						 =       num_channels
								snake_case_				:							Optional[int]						 =       patch_size
								snake_case_				:							Dict						 =       image_size
								snake_case_				:							Tuple						 =       initializer_range
								snake_case_				:							Optional[Any]						 =       initializer_factor
								snake_case_				:							Any						 =       attention_dropout
								snake_case_				:							Tuple						 =       layer_norm_eps
								snake_case_				:							int						 =       hidden_act






						@classmethod
						def       _lowerCAmelCase       (	cls		,				_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE				) ->				"PretrainedConfig":
								cls._set_token_in_kwargs(_SCREAMING_SNAKE_CASE				)

								snake_case_ ,       snake_case_				:							str						 =       cls.get_config_dict(_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE				)

								# get the vision config dict if we are loading from AltCLIPConfig
								if config_dict.get("model_type"				) == "altclip":
										snake_case_				:							List[Any]						 =       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(_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE				)




class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




						A     :   str						=					'altclip'
						A     :   Dict						=					True






						def __init__(	self		,				_SCREAMING_SNAKE_CASE=None		,				_SCREAMING_SNAKE_CASE=None		,				_SCREAMING_SNAKE_CASE=768		,				_SCREAMING_SNAKE_CASE=2.6592		,				**_SCREAMING_SNAKE_CASE				) ->				Optional[int]:
								# If `_config_dict` exist, we use them for the backward compatibility.
								# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
								# of confusion!).
								snake_case_				:							Optional[Any]						 =       kwargs.pop("text_config_dict"		,				_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Dict						 =       kwargs.pop("vision_config_dict"		,				_SCREAMING_SNAKE_CASE				)

								super().__init__(**_SCREAMING_SNAKE_CASE				)

								# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
								# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
								# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
								if text_config_dict is not None:
										if text_config is None:
												snake_case_				:							Any						 =       {}

										# This is the complete result when using `text_config_dict`.
										snake_case_				:							str						 =       AltCLIPTextConfig(**_SCREAMING_SNAKE_CASE				).to_dict()

										# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
										for key, value in _text_config_dict.items():
												if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
														# If specified in `text_config_dict`
														if key in text_config_dict:
																snake_case_				:							Optional[Any]						 =       (
																    f'''`{key}` is found in both `text_config_dict` and `text_config` but with different values. '''
																    f'''The value `text_config_dict["{key}"]` will be used instead.'''
																)
														# If inferred from default argument values (just to be super careful)
														else:
																snake_case_				:							Dict						 =       (
																    f'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
																    f'''value `text_config["{key}"]` will be overriden.'''
																)
														logger.warning(_SCREAMING_SNAKE_CASE				)

            # Update all values in `text_config` with the ones in `_text_config_dict`.
										text_config.update(_text_config_dict				)

								if vision_config_dict is not None:
										if vision_config is None:
												snake_case_				:							str						 =       {}

										# This is the complete result when using `vision_config_dict`.
										snake_case_				:							Optional[Any]						 =       AltCLIPVisionConfig(**_SCREAMING_SNAKE_CASE				).to_dict()
										# convert keys to string instead of integer
										if "id2label" in _vision_config_dict:
												snake_case_				:							Any						 =       {
												    str(_SCREAMING_SNAKE_CASE				): value for key, value in _vision_config_dict["id2label"].items()
												}

										# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
										for key, value in _vision_config_dict.items():
												if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
														# If specified in `vision_config_dict`
														if key in vision_config_dict:
																snake_case_				:							Dict						 =       (
																    f'''`{key}` is found in both `vision_config_dict` and `vision_config` but with different '''
																    f'''values. The value `vision_config_dict["{key}"]` will be used instead.'''
																)
														# If inferred from default argument values (just to be super careful)
														else:
																snake_case_				:							Optional[Any]						 =       (
																    f'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
																    f'''The value `vision_config["{key}"]` will be overriden.'''
																)
														logger.warning(_SCREAMING_SNAKE_CASE				)

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
										vision_config.update(_vision_config_dict				)

								if text_config is None:
										snake_case_				:							Tuple						 =       {}
										logger.info("`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values."				)

								if vision_config is None:
										snake_case_				:							Optional[Any]						 =       {}
										logger.info("`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values."				)

								snake_case_				:							List[Any]						 =       AltCLIPTextConfig(**_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Union[str, Any]						 =       AltCLIPVisionConfig(**_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Optional[int]						 =       projection_dim
								snake_case_				:							Tuple						 =       logit_scale_init_value
								snake_case_				:							List[Any]						 =       1.0






						@classmethod
						def       _lowerCAmelCase       (	cls		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE				) ->				Optional[Any]:
								return cls(text_config=text_config.to_dict()		,				vision_config=vision_config.to_dict()		,				**_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self				) ->				List[str]:
								snake_case_				:							Any						 =       copy.deepcopy(self.__dict__				)
								snake_case_				:							Union[str, Any]						 =       self.text_config.to_dict()
								snake_case_				:							List[Any]						 =       self.vision_config.to_dict()
								snake_case_				:							Tuple						 =       self.__class__.model_type
								return output
