



"""simple docstring"""


import copy

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings


snake_case_    					=	R"""
    [`RagConfig`] stores the configuration of a *RagModel*. Configuration objects inherit from [`PretrainedConfig`] and
    can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information.

    Args:
        title_sep (`str`, *optional*, defaults to  `\" / \"`):
            Separator inserted between the title and the text of the retrieved document when calling [`RagRetriever`].
        doc_sep (`str`, *optional*, defaults to  `\" // \"`):
            Separator inserted between the text of the retrieved document and the original input when calling
            [`RagRetriever`].
        n_docs (`int`, *optional*, defaults to 5):
            Number of documents to retrieve.
        max_combined_length (`int`, *optional*, defaults to 300):
            Max length of contextualized input returned by [`~RagRetriever.__call__`].
        retrieval_vector_size (`int`, *optional*, defaults to 768):
            Dimensionality of the document embeddings indexed by [`RagRetriever`].
        retrieval_batch_size (`int`, *optional*, defaults to 8):
            Retrieval batch size, defined as the number of queries issues concurrently to the faiss index encapsulated
            [`RagRetriever`].
        dataset (`str`, *optional*, defaults to `\"wiki_dpr\"`):
            A dataset identifier of the indexed dataset in HuggingFace Datasets (list all available datasets and ids
            using `datasets.list_datasets()`).
        dataset_split (`str`, *optional*, defaults to `\"train\"`)
            Which split of the `dataset` to load.
        index_name (`str`, *optional*, defaults to `\"compressed\"`)
            The index name of the index associated with the `dataset`. One can choose between `\"legacy\"`, `\"exact\"` and
            `\"compressed\"`.
        index_path (`str`, *optional*)
            The path to the serialized faiss index on disk.
        passages_path (`str`, *optional*):
            A path to text passages compatible with the faiss index. Required if using
            [`~models.rag.retrieval_rag.LegacyIndex`]
        use_dummy_dataset (`bool`, *optional*, defaults to `False`)
            Whether to load a \"dummy\" variant of the dataset specified by `dataset`.
        label_smoothing (`float`, *optional*, defaults to 0.0):
            Only relevant if `return_loss` is set to `True`. Controls the `epsilon` parameter value for label smoothing
            in the loss calculation. If set to 0, no label smoothing is performed.
        do_marginalize (`bool`, *optional*, defaults to `False`):
            If `True`, the logits are marginalized over all documents by making use of
            `torch.nn.functional.log_softmax`.
        reduce_loss (`bool`, *optional*, defaults to `False`):
            Whether or not to reduce the NLL loss using the `torch.Tensor.sum` operation.
        do_deduplication (`bool`, *optional*, defaults to `True`):
            Whether or not to deduplicate the generations from different context documents for a given input. Has to be
            set to `False` if used while training with distributed backend.
        exclude_bos_score (`bool`, *optional*, defaults to `False`):
            Whether or not to disregard the BOS token when computing the loss.
        output_retrieved(`bool`, *optional*, defaults to `False`):
            If set to `True`, `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` and
            `context_attention_mask` are returned. See returned tensors for more detail.
        use_cache (`bool`, *optional*, defaults to `True`):
            Whether or not the model should return the last key/values attentions (not used by all models).
        forced_eos_token_id (`int`, *optional*):
            The id of the token to force as the last generated token when `max_length` is reached. Usually set to
            `eos_token_id`.
"""







@add_start_docstrings(SCREAMING_SNAKE_CASE_    )
class 				A_      (					SCREAMING_SNAKE_CASE_    ):



						"""simple docstring"""
						__UpperCamelCase		    =							"""rag"""
						__UpperCamelCase		    =							True






						def __init__( self			:Optional[int]       ,  lowercase_			:Optional[Any]=None       ,  lowercase_			:List[str]=True       ,  lowercase_			:Tuple=None       ,  lowercase_			:int=None       ,  lowercase_			:Optional[Any]=None       ,  lowercase_			:str=None       ,  lowercase_			:Dict=None       ,  lowercase_			:List[str]=" / "       ,  lowercase_			:Dict=" // "       ,  lowercase_			:str=5       ,  lowercase_			:Optional[int]=3_00       ,  lowercase_			:Dict=7_68       ,  lowercase_			:str=8       ,  lowercase_			:List[str]="wiki_dpr"       ,  lowercase_			:Optional[Any]="train"       ,  lowercase_			:List[str]="compressed"       ,  lowercase_			:str=None       ,  lowercase_			:Optional[Any]=None       ,  lowercase_			:List[str]=False       ,  lowercase_			:List[str]=False       ,  lowercase_			:List[str]=0.0       ,  lowercase_			:Optional[Any]=True       ,  lowercase_			:List[str]=False       ,  lowercase_			:Union[str, Any]=False       ,  lowercase_			:int=False       ,  lowercase_			:List[Any]=True       ,  lowercase_			:Optional[Any]=None       ,  **lowercase_			:int       ,  )    ->      str:
												super().__init__(
												    bos_token_id=lowercase_       ,  pad_token_id=lowercase_       ,  eos_token_id=lowercase_       ,  decoder_start_token_id=lowercase_       ,  forced_eos_token_id=lowercase_       ,  is_encoder_decoder=lowercase_       ,  prefix=lowercase_       ,  vocab_size=lowercase_       ,  **lowercase_       ,  )
												assert (
												    "question_encoder" in kwargs and "generator" in kwargs
												), "Config has to be initialized with question_encoder and generator config"
												UpperCAmelCase					=			kwargs.pop('question_encoder' )
												UpperCAmelCase					=			question_encoder_config.pop('model_type' )
												UpperCAmelCase					=			kwargs.pop('generator' )
												UpperCAmelCase					=			decoder_config.pop('model_type' )

												from ..auto.configuration_auto import AutoConfig

												UpperCAmelCase					=			AutoConfig.for_model(lowercase_       ,  **lowercase_ )
												UpperCAmelCase					=			AutoConfig.for_model(lowercase_       ,  **lowercase_ )

												UpperCAmelCase					=			reduce_loss
												UpperCAmelCase					=			label_smoothing
												UpperCAmelCase					=			exclude_bos_score
												UpperCAmelCase					=			do_marginalize

												UpperCAmelCase					=			title_sep
												UpperCAmelCase					=			doc_sep
												UpperCAmelCase					=			n_docs
												UpperCAmelCase					=			max_combined_length

												UpperCAmelCase					=			dataset
												UpperCAmelCase					=			dataset_split
												UpperCAmelCase					=			index_name

												UpperCAmelCase					=			retrieval_vector_size
												UpperCAmelCase					=			retrieval_batch_size
												UpperCAmelCase					=			passages_path
												UpperCAmelCase					=			index_path
												UpperCAmelCase					=			use_dummy_dataset

												UpperCAmelCase					=			output_retrieved

												UpperCAmelCase					=			do_deduplication

												UpperCAmelCase					=			use_cache

												if self.forced_eos_token_id is None:
																		UpperCAmelCase					=			getattr(self.generator       ,  'forced_eos_token_id'       ,  lowercase_ )






						@classmethod
						def      UpperCAmelCase__					( cls			:Tuple       ,  lowercase_			:PretrainedConfig       ,  lowercase_			:PretrainedConfig       ,  **lowercase_			:Union[str, Any] )    ->      PretrainedConfig:
												return cls(question_encoder=question_encoder_config.to_dict()       ,  generator=generator_config.to_dict()       ,  **lowercase_ )






						def      UpperCAmelCase__					( self			:str )    ->      List[Any]:
												UpperCAmelCase					=			copy.deepcopy(self.__dict__ )
												UpperCAmelCase					=			self.question_encoder.to_dict()
												UpperCAmelCase					=			self.generator.to_dict()
												UpperCAmelCase					=			self.__class__.model_type
												return output










"""simple docstring"""


import copy
from typing import Dict, Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING
from ..detr import DetrConfig
from ..swin import SwinConfig


snake_case_    					=	{
    """facebook/maskformer-swin-base-ade""": (
        """https://huggingface.co/facebook/maskformer-swin-base-ade/blob/main/config.json"""
    )
    # See all MaskFormer models at https://huggingface.co/models?filter=maskformer
}

snake_case_    					=	logging.get_logger(__name__)







class 				A_      (					SCREAMING_SNAKE_CASE_    ):



						"""simple docstring"""
						__UpperCamelCase		    =							"""maskformer"""
						__UpperCamelCase		    =							{"""hidden_size""": """mask_feature_size"""}
						__UpperCamelCase		    =							["""resnet""", """swin"""]
						__UpperCamelCase		    =							["""detr"""]






						def __init__( self			:Dict       ,  lowercase_			:int = 2_56       ,  lowercase_			:int = 2_56       ,  lowercase_			:float = 0.1       ,  lowercase_			:bool = False       ,  lowercase_			:Optional[Dict] = None       ,  lowercase_			:Optional[Dict] = None       ,  lowercase_			:float = 0.02       ,  lowercase_			:float = 1.0       ,  lowercase_			:float = 1.0       ,  lowercase_			:float = 1.0       ,  lowercase_			:float = 20.0       ,  lowercase_			:Optional[bool] = None       ,  **lowercase_			:List[str]       ,  )    ->      Optional[int]:
												if backbone_config is None:
																		# fall back to https://huggingface.co/microsoft/swin-base-patch4-window12-384-in22k
																		UpperCAmelCase					=			SwinConfig(
																		    image_size=3_84       ,  in_channels=3       ,  patch_size=4       ,  embed_dim=1_28       ,  depths=[2, 2, 18, 2]       ,  num_heads=[4, 8, 16, 32]       ,  window_size=12       ,  drop_path_rate=0.3       ,  out_features=['stage1', 'stage2', 'stage3', 'stage4']       ,  )

												if isinstance(lowercase_       ,  lowercase_ ):
																		UpperCAmelCase					=			backbone_config.pop('model_type' )
																		UpperCAmelCase					=			CONFIG_MAPPING[backbone_model_type]
																		UpperCAmelCase					=			config_class.from_dict(lowercase_ )

												# verify that the backbone is supported
												if backbone_config.model_type not in self.backbones_supported:
																		logger.warning_once(
																		    f"""Backbone {backbone_config.model_type} is not a supported model and may not be compatible with MaskFormer. """
																		    f"""Supported model types: {','.join(self.backbones_supported )}""" )

												if decoder_config is None:
																		# fall back to https://huggingface.co/facebook/detr-resnet-50
																		UpperCAmelCase					=			DetrConfig()
												else:
																		# verify that the decoder is supported
																		UpperCAmelCase					=			(
																		    decoder_config.pop('model_type' ) if isinstance(lowercase_       ,  lowercase_ ) else decoder_config.model_type
																		)
																		if decoder_type not in self.decoders_supported:
																								raise ValueError(
																								    f"""Transformer Decoder {decoder_type} not supported, please use one of"""
																								    f""" {','.join(self.decoders_supported )}""" )
																		if isinstance(lowercase_       ,  lowercase_ ):
																								UpperCAmelCase					=			CONFIG_MAPPING[decoder_type]
																								UpperCAmelCase					=			config_class.from_dict(lowercase_ )

												UpperCAmelCase					=			backbone_config
												UpperCAmelCase					=			decoder_config
												# main feature dimension for the model
												UpperCAmelCase					=			fpn_feature_size
												UpperCAmelCase					=			mask_feature_size
												# initializer
												UpperCAmelCase					=			init_std
												UpperCAmelCase					=			init_xavier_std
												# Hungarian matcher && loss
												UpperCAmelCase					=			cross_entropy_weight
												UpperCAmelCase					=			dice_weight
												UpperCAmelCase					=			mask_weight
												UpperCAmelCase					=			use_auxiliary_loss
												UpperCAmelCase					=			no_object_weight
												UpperCAmelCase					=			output_auxiliary_logits

												UpperCAmelCase					=			self.decoder_config.encoder_attention_heads
												UpperCAmelCase					=			self.decoder_config.num_hidden_layers
												super().__init__(**lowercase_ )






						@classmethod
						def      UpperCAmelCase__					( cls			:int       ,  lowercase_			:PretrainedConfig       ,  lowercase_			:PretrainedConfig       ,  **lowercase_			:int )    ->      List[Any]:
												return cls(
												    backbone_config=lowercase_       ,  decoder_config=lowercase_       ,  **lowercase_       ,  )






						def      UpperCAmelCase__					( self			:Tuple )    ->      Dict[str, any]:
												UpperCAmelCase					=			copy.deepcopy(self.__dict__ )
												UpperCAmelCase					=			self.backbone_config.to_dict()
												UpperCAmelCase					=			self.decoder_config.to_dict()
												UpperCAmelCase					=			self.__class__.model_type
												return output





