
'''simple docstring'''
from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import get_down_block, get_mid_block, get_out_block, get_up_block







@dataclass
class  __A				( snake_case__			):
 lowerCamelCase				       =42







class  __A				( snake_case__    ,						snake_case__			):
 @register_to_config
 def __init__(   self			:    Tuple				,   lowerCamelCase			:    int = 6_55_36				,   lowerCamelCase			:    Optional[int] = None				,   lowerCamelCase			:    int = 2				,   lowerCamelCase			:    int = 2				,   lowerCamelCase			:    int = 0				,   lowerCamelCase			:    str = "fourier"				,   lowerCamelCase			:    bool = True				,   lowerCamelCase			:    bool = False				,   lowerCamelCase			:    float = 0.0				,   lowerCamelCase			:    Tuple[str] = ("DownBlock1DNoSkip", "DownBlock1D", "AttnDownBlock1D")				,   lowerCamelCase			:    Tuple[str] = ("AttnUpBlock1D", "UpBlock1D", "UpBlock1DNoSkip")				,   lowerCamelCase			:    Tuple[str] = "UNetMidBlock1D"				,   lowerCamelCase			:    str = None				,   lowerCamelCase			:    Tuple[int] = (32, 32, 64)				,   lowerCamelCase			:    str = None				,   lowerCamelCase			:    int = 8				,   lowerCamelCase			:    int = 1				,   lowerCamelCase			:    bool = False				,   ):



   """simple docstring"""





   super().__init__()
   __A		:     List[str]												=		sample_size

   # time
   if time_embedding_type == "fourier":
     __A		:     Union[str, Any]												=		GaussianFourierProjection(
         embedding_size=8				,   set_W_to_weight=UpperCAmelCase_				,   log=UpperCAmelCase_				,   flip_sin_to_cos=UpperCAmelCase_       )
     __A		:     int												=		2 * block_out_channels[0]
   elif time_embedding_type == "positional":
     __A		:     Any												=		Timesteps(
         block_out_channels[0]				,   flip_sin_to_cos=UpperCAmelCase_				,   downscale_freq_shift=UpperCAmelCase_       )
     __A		:     Optional[Any]												=		block_out_channels[0]

   if use_timestep_embedding:
     __A		:     Any												=		block_out_channels[0] * 4
     __A		:     List[str]												=		TimestepEmbedding(
         in_channels=UpperCAmelCase_				,   time_embed_dim=UpperCAmelCase_				,   act_fn=UpperCAmelCase_				,   out_dim=block_out_channels[0]				,   )

   __A		:     Any												=		nn.ModuleList([]       )
   __A		:     str												=		None
   __A		:     List[Any]												=		nn.ModuleList([]       )
   __A		:     Dict												=		None

   # down
   __A		:     Optional[Any]												=		in_channels
   for i, down_block_type in enumerate(UpperCAmelCase_       ):
     __A		:     Union[str, Any]												=		output_channel
     __A		:     Optional[Any]												=		block_out_channels[i]

     if i == 0:
       input_channel += extra_in_channels

     __A		:     str												=		i == len(UpperCAmelCase_       ) - 1

     __A		:     Dict												=		get_down_block(
         UpperCAmelCase_				,   num_layers=UpperCAmelCase_				,   in_channels=UpperCAmelCase_				,   out_channels=UpperCAmelCase_				,   temb_channels=block_out_channels[0]				,   add_downsample=not is_final_block or downsample_each_block				,   )
     self.down_blocks.append(UpperCAmelCase_       )

   # mid
   __A		:     List[Any]												=		get_mid_block(
       UpperCAmelCase_				,   in_channels=block_out_channels[-1]				,   mid_channels=block_out_channels[-1]				,   out_channels=block_out_channels[-1]				,   embed_dim=block_out_channels[0]				,   num_layers=UpperCAmelCase_				,   add_downsample=UpperCAmelCase_				,   )

   # up
   __A		:     str												=		list(reversed(UpperCAmelCase_       )       )
   __A		:     Any												=		reversed_block_out_channels[0]
   if out_block_type is None:
     __A		:     Union[str, Any]												=		out_channels
   else:
     __A		:     Dict												=		block_out_channels[0]

   for i, up_block_type in enumerate(UpperCAmelCase_       ):
     __A		:     int												=		output_channel
     __A		:     str												=		(
         reversed_block_out_channels[i + 1] if i < len(UpperCAmelCase_       ) - 1 else final_upsample_channels
     )

     __A		:     str												=		i == len(UpperCAmelCase_       ) - 1

     __A		:     Optional[Any]												=		get_up_block(
         UpperCAmelCase_				,   num_layers=UpperCAmelCase_				,   in_channels=UpperCAmelCase_				,   out_channels=UpperCAmelCase_				,   temb_channels=block_out_channels[0]				,   add_upsample=not is_final_block				,   )
     self.up_blocks.append(UpperCAmelCase_       )
     __A		:     str												=		output_channel

   # out
   __A		:     Tuple												=		norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4				,   32       )
   __A		:     str												=		get_out_block(
       out_block_type=UpperCAmelCase_				,   num_groups_out=UpperCAmelCase_				,   embed_dim=block_out_channels[0]				,   out_channels=UpperCAmelCase_				,   act_fn=UpperCAmelCase_				,   fc_dim=block_out_channels[-1] // 4				,   )






 def 		lowercase_(   self			:    Any				,   lowerCamelCase			:    torch.FloatTensor				,   lowerCamelCase			:    Union[torch.Tensor, float, int]				,   lowerCamelCase			:    bool = True				,   ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		timestep
   if not torch.is_tensor(UpperCAmelCase_       ):
     __A		:     int												=		torch.tensor([timesteps]				,   dtype=torch.long				,   device=sample.device       )
   elif torch.is_tensor(UpperCAmelCase_       ) and len(timesteps.shape       ) == 0:
     __A		:     Union[str, Any]												=		timesteps[None].to(sample.device       )

   __A		:     Optional[int]												=		self.time_proj(UpperCAmelCase_       )
   if self.config.use_timestep_embedding:
     __A		:     Tuple												=		self.time_mlp(UpperCAmelCase_       )
   else:
     __A		:     List[str]												=		timestep_embed[..., None]
     __A		:     Optional[Any]												=		timestep_embed.repeat([1, 1, sample.shape[2]]       ).to(sample.dtype       )
     __A		:     List[str]												=		timestep_embed.broadcast_to((sample.shape[:1] + timestep_embed.shape[1:])       )

   # 2. down
   __A		:     Optional[int]												=		()
   for downsample_block in self.down_blocks:
     __A							,					__A		:     Dict												=		downsample_block(hidden_states=UpperCAmelCase_				,   temb=UpperCAmelCase_       )
     down_block_res_samples += res_samples

   # 3. mid
   if self.mid_block:
     __A		:     str												=		self.mid_block(UpperCAmelCase_				,   UpperCAmelCase_       )

   # 4. up
   for i, upsample_block in enumerate(self.up_blocks       ):
     __A		:     Any												=		down_block_res_samples[-1:]
     __A		:     Any												=		down_block_res_samples[:-1]
     __A		:     Any												=		upsample_block(UpperCAmelCase_				,   res_hidden_states_tuple=UpperCAmelCase_				,   temb=UpperCAmelCase_       )

   # 5. post-process
   if self.out_block:
     __A		:     Any												=		self.out_block(UpperCAmelCase_				,   UpperCAmelCase_       )

   if not return_dict:
     return (sample,)

   return UNetaDOutput(sample=UpperCAmelCase_       )





'''simple docstring'''
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


A__   :		Any 		=logging.get_logger(__name__)

A__   :		Any 		={
    'Salesforce/instruct-blip-flan-t5': 'https://huggingface.co/Salesforce/instruct-blip-flan-t5/resolve/main/config.json',
}







class  __A				( _SCREAMING_SNAKE_CASE			):
 lowerCamelCase				       ='''instructblip_vision_model'''
 def __init__(   self			:    Tuple				,   lowerCamelCase			:    Optional[int]=14_08				,   lowerCamelCase			:    str=61_44				,   lowerCamelCase			:    List[Any]=39				,   lowerCamelCase			:    Optional[Any]=16				,   lowerCamelCase			:    Optional[int]=2_24				,   lowerCamelCase			:    Any=14				,   lowerCamelCase			:    str="gelu"				,   lowerCamelCase			:    str=1e-6				,   lowerCamelCase			:    Dict=0.0				,   lowerCamelCase			:    Dict=1e-1_0				,   lowerCamelCase			:    Optional[Any]=True				,   **lowerCamelCase			:    List[str]				,   ):



   """simple docstring"""





   super().__init__(**lowerCamelCase       )

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






 @classmethod
 def 		lowercase_(   cls			:    Union[str, Any]				,   lowerCamelCase			:    Union[str, os.PathLike]				,   **lowerCamelCase			:    str       ):



   """simple docstring"""





   cls._set_token_in_kwargs(lowerCamelCase       )

   __A							,					__A		:     int												=		cls.get_config_dict(lowerCamelCase				,   **lowerCamelCase       )

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







class  __A				( _SCREAMING_SNAKE_CASE			):
 lowerCamelCase				       ='''instructblip_qformer'''
 def __init__(   self			:    Tuple				,   lowerCamelCase			:    int=3_05_22				,   lowerCamelCase			:    Tuple=7_68				,   lowerCamelCase			:    Optional[Any]=12				,   lowerCamelCase			:    Tuple=12				,   lowerCamelCase			:    str=30_72				,   lowerCamelCase			:    int="gelu"				,   lowerCamelCase			:    Union[str, Any]=0.1				,   lowerCamelCase			:    List[str]=0.1				,   lowerCamelCase			:    int=5_12				,   lowerCamelCase			:    Tuple=0.02				,   lowerCamelCase			:    List[str]=1e-1_2				,   lowerCamelCase			:    int=0				,   lowerCamelCase			:    List[str]="absolute"				,   lowerCamelCase			:    Optional[Any]=2				,   lowerCamelCase			:    List[Any]=14_08				,   **lowerCamelCase			:    List[Any]				,   ):



   """simple docstring"""





   super().__init__(pad_token_id=lowerCamelCase				,   **lowerCamelCase       )

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






 @classmethod
 def 		lowercase_(   cls			:    Any				,   lowerCamelCase			:    Union[str, os.PathLike]				,   **lowerCamelCase			:    Union[str, Any]       ):



   """simple docstring"""





   cls._set_token_in_kwargs(lowerCamelCase       )

   __A							,					__A		:     List[str]												=		cls.get_config_dict(lowerCamelCase				,   **lowerCamelCase       )

   # get the qformer config dict if we are loading from InstructBlipConfig
   if config_dict.get("""model_type"""       ) == "instructblip":
     __A		:     Optional[int]												=		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(lowerCamelCase				,   **lowerCamelCase       )







class  __A				( _SCREAMING_SNAKE_CASE			):
 lowerCamelCase				       ='''instructblip'''
 lowerCamelCase				       =True
 def __init__(   self			:    Any				,   lowerCamelCase			:    Optional[Any]=None				,   lowerCamelCase			:    List[str]=None				,   lowerCamelCase			:    Any=None				,   lowerCamelCase			:    Any=32				,   **lowerCamelCase			:    int       ):



   """simple docstring"""





   super().__init__(**lowerCamelCase       )

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

   if qformer_config is None:
     __A		:     Dict												=		{}
     logger.info("""qformer_config is None. Initializing the InstructBlipQFormerConfig with default values."""       )

   if text_config is None:
     __A		:     Any												=		{}
     logger.info("""text_config is None. Initializing the text config with default values (`OPTConfig`)."""       )

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

   __A		:     Optional[int]												=		self.text_config.tie_word_embeddings
   __A		:     Dict												=		self.text_config.is_encoder_decoder

   __A		:     Optional[int]												=		num_query_tokens
   __A		:     int												=		self.vision_config.hidden_size
   __A		:     str												=		self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
   __A		:     Optional[Any]												=		1.0
   __A		:     Optional[int]												=		0.02
 @classmethod
 def 		lowercase_(   cls			:    List[str]				,   lowerCamelCase			:    InstructBlipVisionConfig				,   lowerCamelCase			:    InstructBlipQFormerConfig				,   lowerCamelCase			:    PretrainedConfig				,   **lowerCamelCase			:    Optional[int]				,   ):



   """simple docstring"""





   return cls(
       vision_config=vision_config.to_dict()				,   qformer_config=qformer_config.to_dict()				,   text_config=text_config.to_dict()				,   **lowerCamelCase				,   )






 def 		lowercase_(   self			:    List[Any]       ):



   """simple docstring"""





   __A		:     Tuple												=		copy.deepcopy(self.__dict__       )
   __A		:     Optional[int]												=		self.vision_config.to_dict()
   __A		:     Optional[Any]												=		self.qformer_config.to_dict()
   __A		:     List[Any]												=		self.text_config.to_dict()
   __A		:     Optional[int]												=		self.__class__.model_type
   return output



