






import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu



class 							SCREAMING_SNAKE_CASE__		(       unittest.TestCase		):





					"""simple docstring"""






					def  _lowercase  (      self  :						str ):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()



					@property
					def  _lowercase  (      self  :						int ):
						snake_case__				:   Any     =						1
						snake_case__				:   Dict     =						3
						snake_case__				:   Union[str, Any]     =						(3_2, 3_2)

						snake_case__				:   Union[str, Any]     =						floats_tensor((batch_size, num_channels) + sizes							,	rng=random.Random(0 ) ).to(__A )
						return image



					@property
					def  _lowercase  (      self  :						List[str] ):
						torch.manual_seed(0 )
						snake_case__				:   List[Any]     =						UNetaDConditionModel(
						    block_out_channels=(3_2, 6_4)							,	layers_per_block=2							,	sample_size=3_2							,	in_channels=4							,	out_channels=4							,	down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")							,	up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")							,	cross_attention_dim=3_2							,	)
						return model



					@property
					def  _lowercase  (      self  :						str ):
						torch.manual_seed(0 )
						snake_case__				:   Dict     =						AutoencoderKL(
						    block_out_channels=[3_2, 6_4]							,	in_channels=3							,	out_channels=3							,	down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]							,	up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]							,	latent_channels=4							,	)
						return model



					@property
					def  _lowercase  (      self  :						Optional[Any] ):
						torch.manual_seed(0 )
						snake_case__				:   List[str]     =						CLIPTextConfig(
						    bos_token_id=0							,	eos_token_id=2							,	hidden_size=3_2							,	intermediate_size=3_7							,	layer_norm_eps=1e-0_5							,	num_attention_heads=4							,	num_hidden_layers=5							,	pad_token_id=1							,	vocab_size=1_0_0_0							,	)
						return CLIPTextModel(__A )



					@property
					def  _lowercase  (      self  :						int ):
						def extract(*__A  :						str							,	**__A  :						List[str] ):



							class 							SCREAMING_SNAKE_CASE__		:





												"""simple docstring"""






												def __init__(      self  :						Optional[Any] ):
													snake_case__				:   str     =						torch.ones([0] )






												def  _lowercase  (      self  :						Any							,	__A  :						str ):
													self.pixel_values.to(__A )
													return self
							return Out()

						return extract



					def  _lowercase  (      self  :						Union[str, Any] ):
						snake_case__				:   Optional[Any]     =						"cpu"  # ensure determinism for the device-dependent torch.Generator
						snake_case__				:   Optional[Any]     =						self.dummy_cond_unet
						snake_case__				:   Optional[Any]     =						DDIMScheduler(
						    beta_start=0.0_0_0_8_5							,	beta_end=0.0_1_2							,	beta_schedule="scaled_linear"							,	clip_sample=__A							,	set_alpha_to_one=__A							,	)

						snake_case__				:   Dict     =						self.dummy_vae
						snake_case__				:   Union[str, Any]     =						self.dummy_text_encoder
						snake_case__				:   Dict     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

						# make sure here that pndm scheduler skips prk
						snake_case__				:   Dict     =						StableDiffusionPipeline(
						    unet=__A							,	scheduler=__A							,	vae=__A							,	text_encoder=__A							,	tokenizer=__A							,	safety_checker=__A							,	feature_extractor=self.dummy_extractor							,	)
						snake_case__				:   Any     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   str     =						"A painting of a squirrel eating a burger"

						snake_case__				:   Optional[int]     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   Optional[Any]     =						sd_pipe([prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np" )
						snake_case__				:   int     =						output.images

						snake_case__				:   Dict     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   int     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np"							,	return_dict=__A							,	)[0]

						snake_case__				:   Tuple     =						image[0, -3:, -3:, -1]
						snake_case__				:   Optional[Any]     =						image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)
						snake_case__				:   int     =						np.array([0.5_7_5_6, 0.6_1_1_8, 0.5_0_0_5, 0.5_0_4_1, 0.5_4_7_1, 0.4_7_2_6, 0.4_9_7_6, 0.4_8_6_5, 0.4_8_6_4] )

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2



					def  _lowercase  (      self  :						Dict ):
						snake_case__				:   List[Any]     =						"cpu"  # ensure determinism for the device-dependent torch.Generator
						snake_case__				:   Any     =						self.dummy_cond_unet
						snake_case__				:   List[Any]     =						PNDMScheduler(skip_prk_steps=__A )
						snake_case__				:   List[Any]     =						self.dummy_vae
						snake_case__				:   Tuple     =						self.dummy_text_encoder
						snake_case__				:   Optional[Any]     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

						# make sure here that pndm scheduler skips prk
						snake_case__				:   Dict     =						StableDiffusionPipeline(
						    unet=__A							,	scheduler=__A							,	vae=__A							,	text_encoder=__A							,	tokenizer=__A							,	safety_checker=__A							,	feature_extractor=self.dummy_extractor							,	)
						snake_case__				:   List[str]     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   List[str]     =						"A painting of a squirrel eating a burger"
						snake_case__				:   Union[str, Any]     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   Optional[int]     =						sd_pipe([prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np" )

						snake_case__				:   Tuple     =						output.images

						snake_case__				:   int     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   str     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np"							,	return_dict=__A							,	)[0]

						snake_case__				:   List[str]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Optional[int]     =						image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)
						snake_case__				:   Dict     =						np.array([0.5_1_2_5, 0.5_7_1_6, 0.4_8_2_8, 0.5_0_6_0, 0.5_6_5_0, 0.4_7_6_8, 0.5_1_8_5, 0.4_8_9_5, 0.4_9_9_3] )

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2



					def  _lowercase  (      self  :						str ):
						snake_case__				:   Dict     =						StableDiffusionPipeline.from_pretrained(
						    "hf-internal-testing/tiny-stable-diffusion-lms-pipe"							,	safety_checker=__A )
						assert isinstance(__A							,	__A )
						assert isinstance(pipe.scheduler							,	__A )
						assert pipe.safety_checker is None

						snake_case__				:   List[str]     =						pipe("example prompt"							,	num_inference_steps=2 ).images[0]
						assert image is not None

						# check that there's no error when saving a pipeline with one of the models being None
						with tempfile.TemporaryDirectory() as tmpdirname:
							pipe.save_pretrained(__A )
							snake_case__				:   Optional[int]     =						StableDiffusionPipeline.from_pretrained(__A )

						# sanity check that the pipeline still works
						assert pipe.safety_checker is None
						snake_case__				:   Dict     =						pipe("example prompt"							,	num_inference_steps=2 ).images[0]
						assert image is not None






					@unittest.skipIf(torch_device != "cuda"							,	"This test requires a GPU" )
					def  _lowercase  (      self  :						Union[str, Any] ):
						snake_case__				:   Any     =						self.dummy_cond_unet
						snake_case__				:   List[str]     =						PNDMScheduler(skip_prk_steps=__A )
						snake_case__				:   List[Any]     =						self.dummy_vae
						snake_case__				:   Union[str, Any]     =						self.dummy_text_encoder
						snake_case__				:   str     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

						# put models in fp16
						snake_case__				:   List[Any]     =						unet.half()
						snake_case__				:   Dict     =						vae.half()
						snake_case__				:   str     =						bert.half()

						# make sure here that pndm scheduler skips prk
						snake_case__				:   Dict     =						StableDiffusionPipeline(
						    unet=__A							,	scheduler=__A							,	vae=__A							,	text_encoder=__A							,	tokenizer=__A							,	safety_checker=__A							,	feature_extractor=self.dummy_extractor							,	)
						snake_case__				:   Tuple     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   List[str]     =						"A painting of a squirrel eating a burger"
						snake_case__				:   Optional[Any]     =						sd_pipe([prompt]							,	num_inference_steps=2							,	output_type="np" ).images

						assert image.shape == (1, 6_4, 6_4, 3)



@nightly
@require_torch_gpu
class 							SCREAMING_SNAKE_CASE__		(       unittest.TestCase		):





					"""simple docstring"""






					def  _lowercase  (      self  :						Union[str, Any] ):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()



					def  _lowercase  (      self  :						List[Any] ):
						snake_case__				:   Dict     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"							,	safety_checker=__A )
						snake_case__				:   Union[str, Any]     =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config )
						snake_case__				:   Dict     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   Optional[int]     =						(
						    "portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"
						    " coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"
						    " anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"
						    " children from bahnhof zoo, detailed "
						)
						snake_case__				:   Optional[int]     =						4_0_0_3_6_6_0_3_4_6
						snake_case__				:   Tuple     =						7

						# without safety guidance (sld_guidance_scale = 0)
						snake_case__				:   Optional[Any]     =						torch.manual_seed(__A )
						snake_case__				:   Optional[int]     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=0							,	)

						snake_case__				:   Dict     =						output.images
						snake_case__				:   List[Any]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Tuple     =						[0.2_2_7_8, 0.2_2_3_1, 0.2_2_4_9, 0.2_3_3_3, 0.2_3_0_3, 0.1_8_8_5, 0.2_2_7_3, 0.2_1_4_4, 0.2_1_7_6]

						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2

						# without safety guidance (strong configuration)
						snake_case__				:   Any     =						torch.manual_seed(__A )
						snake_case__				:   Dict     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=2_0_0_0							,	sld_warmup_steps=7							,	sld_threshold=0.0_2_5							,	sld_momentum_scale=0.5							,	sld_mom_beta=0.7							,	)

						snake_case__				:   List[str]     =						output.images
						snake_case__				:   Any     =						image[0, -3:, -3:, -1]
						snake_case__				:   str     =						[0.2_3_8_3, 0.2_2_7_6, 0.2_3_6, 0.2_1_9_2, 0.2_1_8_6, 0.2_0_5_3, 0.1_9_7_1, 0.1_9_0_1, 0.1_7_1_9]

						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2



					def  _lowercase  (      self  :						Tuple ):
						snake_case__				:   Any     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"							,	safety_checker=__A )
						snake_case__				:   Any     =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config )
						snake_case__				:   List[str]     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   Optional[Any]     =						"padme amidala taking a bath artwork, safe for work, no nudity"
						snake_case__				:   Any     =						2_7_3_4_9_7_1_7_5_5
						snake_case__				:   List[Any]     =						7

						snake_case__				:   int     =						torch.manual_seed(__A )
						snake_case__				:   Any     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=0							,	)

						snake_case__				:   List[Any]     =						output.images
						snake_case__				:   Optional[int]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Optional[Any]     =						[0.3_5_0_2, 0.3_6_2_2, 0.3_3_9_6, 0.3_6_4_2, 0.3_4_7_8, 0.3_3_1_8, 0.3_5, 0.3_3_4_8, 0.3_2_9_7]

						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2

						snake_case__				:   Dict     =						torch.manual_seed(__A )
						snake_case__				:   str     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=2_0_0_0							,	sld_warmup_steps=7							,	sld_threshold=0.0_2_5							,	sld_momentum_scale=0.5							,	sld_mom_beta=0.7							,	)

						snake_case__				:   Optional[int]     =						output.images
						snake_case__				:   Dict     =						image[0, -3:, -3:, -1]
						snake_case__				:   Any     =						[0.5_5_3_1, 0.5_2_0_6, 0.4_8_9_5, 0.5_1_5_6, 0.5_1_8_2, 0.4_7_5_1, 0.4_8_0_2, 0.4_8_0_3, 0.4_4_4_3]

						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2






					def  _lowercase  (      self  :						int ):
						snake_case__				:   str     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5" )
						snake_case__				:   Any     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   Union[str, Any]     =						(
						    "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
						    " leyendecker"
						)
						snake_case__				:   Any     =						1_0_4_4_3_5_5_2_3_4
						snake_case__				:   List[str]     =						1_2

						snake_case__				:   Dict     =						torch.manual_seed(__A )
						snake_case__				:   List[str]     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=0							,	)

						snake_case__				:   List[Any]     =						output.images
						snake_case__				:   Any     =						image[0, -3:, -3:, -1]
						snake_case__				:   str     =						np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] )

						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-7

						snake_case__				:   Tuple     =						torch.manual_seed(__A )
						snake_case__				:   Any     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=2_0_0_0							,	sld_warmup_steps=7							,	sld_threshold=0.0_2_5							,	sld_momentum_scale=0.5							,	sld_mom_beta=0.7							,	)

						snake_case__				:   Optional[Any]     =						output.images
						snake_case__				:   Union[str, Any]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Any     =						np.array([0.5_8_1_8, 0.6_2_8_5, 0.6_8_3_5, 0.6_0_1_9, 0.6_2_5, 0.6_7_5_4, 0.6_0_9_6, 0.6_3_3_4, 0.6_5_6_1] )
						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2











import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
from ...utils import logging
from ..auto import CONFIG_MAPPING


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

__lowerCamelCase      :    Dict   		=   {
    """Salesforce/instruct-blip-flan-t5""": """https://huggingface.co/Salesforce/instruct-blip-flan-t5/resolve/main/config.json""",
}



class 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					a_			=	"instructblip_vision_model"



					def __init__(      self  :						List[Any]							,	__A  :						Dict=1_4_0_8							,	__A  :						Tuple=6_1_4_4							,	__A  :						str=3_9							,	__A  :						int=1_6							,	__A  :						str=2_2_4							,	__A  :						Any=1_4							,	__A  :						Dict="gelu"							,	__A  :						List[Any]=1e-6							,	__A  :						Any=0.0							,	__A  :						List[Any]=1e-1_0							,	__A  :						Union[str, Any]=True							,	**__A  :						Tuple							,	):
						super().__init__(**__A )

						snake_case__				:   List[str]     =						hidden_size
						snake_case__				:   Optional[int]     =						intermediate_size
						snake_case__				:   List[str]     =						num_hidden_layers
						snake_case__				:   List[Any]     =						num_attention_heads
						snake_case__				:   str     =						patch_size
						snake_case__				:   int     =						image_size
						snake_case__				:   int     =						initializer_range
						snake_case__				:   Optional[int]     =						attention_dropout
						snake_case__				:   str     =						layer_norm_eps
						snake_case__				:   Optional[Any]     =						hidden_act
						snake_case__				:   Tuple     =						qkv_bias






					@classmethod
					def  _lowercase  (      cls  :						List[str]							,	__A  :						Union[str, os.PathLike]							,	**__A  :						Optional[Any] ):
						cls._set_token_in_kwargs(__A )

						snake_case__,		snake_case__				:   str     =						cls.get_config_dict(__A							,	**__A )

						# get the vision config dict if we are loading from InstructBlipConfig
						if config_dict.get("model_type" ) == "instructblip":
							snake_case__				:   Union[str, 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(__A							,	**__A )



class 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					a_			=	"instructblip_qformer"



					def __init__(      self  :						Any							,	__A  :						Union[str, Any]=3_0_5_2_2							,	__A  :						Union[str, Any]=7_6_8							,	__A  :						Optional[int]=1_2							,	__A  :						Dict=1_2							,	__A  :						Dict=3_0_7_2							,	__A  :						List[str]="gelu"							,	__A  :						Union[str, Any]=0.1							,	__A  :						Tuple=0.1							,	__A  :						Any=5_1_2							,	__A  :						Optional[int]=0.0_2							,	__A  :						List[str]=1e-1_2							,	__A  :						Any=0							,	__A  :						Optional[Any]="absolute"							,	__A  :						str=2							,	__A  :						Any=1_4_0_8							,	**__A  :						List[str]							,	):
						super().__init__(pad_token_id=__A							,	**__A )

						snake_case__				:   Dict     =						vocab_size
						snake_case__				:   Optional[int]     =						hidden_size
						snake_case__				:   Optional[Any]     =						num_hidden_layers
						snake_case__				:   str     =						num_attention_heads
						snake_case__				:   int     =						hidden_act
						snake_case__				:   Optional[Any]     =						intermediate_size
						snake_case__				:   Union[str, Any]     =						hidden_dropout_prob
						snake_case__				:   List[Any]     =						attention_probs_dropout_prob
						snake_case__				:   List[Any]     =						max_position_embeddings
						snake_case__				:   int     =						initializer_range
						snake_case__				:   Dict     =						layer_norm_eps
						snake_case__				:   str     =						position_embedding_type
						snake_case__				:   Dict     =						cross_attention_frequency
						snake_case__				:   List[str]     =						encoder_hidden_size






					@classmethod
					def  _lowercase  (      cls  :						List[Any]							,	__A  :						Union[str, os.PathLike]							,	**__A  :						Optional[int] ):
						cls._set_token_in_kwargs(__A )

						snake_case__,		snake_case__				:   Tuple     =						cls.get_config_dict(__A							,	**__A )

						# get the qformer config dict if we are loading from InstructBlipConfig
						if config_dict.get("model_type" ) == "instructblip":
							snake_case__				:   List[Any]     =						config_dict["qformer_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 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					a_			=	"instructblip"
					a_			=	True



					def __init__(      self  :						List[str]							,	__A  :						Optional[Any]=None							,	__A  :						Tuple=None							,	__A  :						Optional[int]=None							,	__A  :						Optional[Any]=3_2							,	**__A  :						Optional[int] ):
						super().__init__(**__A )

						if vision_config is None:
							snake_case__				:   Any     =						{}
							logger.info("vision_config is None. initializing the InstructBlipVisionConfig with default values." )

						if qformer_config is None:
							snake_case__				:   Optional[Any]     =						{}
							logger.info("qformer_config is None. Initializing the InstructBlipQFormerConfig with default values." )

						if text_config is None:
							snake_case__				:   Optional[int]     =						{}
							logger.info("text_config is None. Initializing the text config with default values (`OPTConfig`)." )

						snake_case__				:   List[Any]     =						InstructBlipVisionConfig(**__A )
						snake_case__				:   Union[str, Any]     =						InstructBlipQFormerConfig(**__A )
						snake_case__				:   Dict     =						text_config["model_type"] if "model_type" in text_config else "opt"
						snake_case__				:   List[Any]     =						CONFIG_MAPPING[text_model_type](**__A )

						snake_case__				:   Union[str, Any]     =						self.text_config.tie_word_embeddings
						snake_case__				:   Tuple     =						self.text_config.is_encoder_decoder

						snake_case__				:   str     =						num_query_tokens
						snake_case__				:   Dict     =						self.vision_config.hidden_size
						snake_case__				:   List[Any]     =						self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
						snake_case__				:   int     =						1.0
						snake_case__				:   Optional[int]     =						0.0_2



					@classmethod
					def  _lowercase  (      cls  :						List[str]							,	__A  :						InstructBlipVisionConfig							,	__A  :						InstructBlipQFormerConfig							,	__A  :						PretrainedConfig							,	**__A  :						int							,	):
						return cls(
						    vision_config=vision_config.to_dict()							,	qformer_config=qformer_config.to_dict()							,	text_config=text_config.to_dict()							,	**__A							,	)






					def  _lowercase  (      self  :						Optional[int] ):
						snake_case__				:   Any     =						copy.deepcopy(self.__dict__ )
						snake_case__				:   Optional[Any]     =						self.vision_config.to_dict()
						snake_case__				:   List[str]     =						self.qformer_config.to_dict()
						snake_case__				:   List[Any]     =						self.text_config.to_dict()
						snake_case__				:   List[Any]     =						self.__class__.model_type
						return output



