






"""simple docstring"""

import copy

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


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


@add_start_docstrings(A__     )
class 						__lowerCamelCase							(					A__     ):





		'''simple docstring'''






		a_      :							Tuple  =				"""rag"""
		a_      :							str  =				True





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

				from ..auto.configuration_auto import AutoConfig

				lowerCAmelCase_  :				List[str]   							=     AutoConfig.for_model(UpperCamelCase_		,     **UpperCamelCase_      )
				lowerCAmelCase_  :				int   							=     AutoConfig.for_model(UpperCamelCase_		,     **UpperCamelCase_      )

				lowerCAmelCase_  :				Optional[int]   							=     reduce_loss
				lowerCAmelCase_  :				Optional[Any]   							=     label_smoothing
				lowerCAmelCase_  :				Any   							=     exclude_bos_score
				lowerCAmelCase_  :				str   							=     do_marginalize

				lowerCAmelCase_  :				Union[str, Any]   							=     title_sep
				lowerCAmelCase_  :				str   							=     doc_sep
				lowerCAmelCase_  :				Any   							=     n_docs
				lowerCAmelCase_  :				Dict   							=     max_combined_length

				lowerCAmelCase_  :				Optional[int]   							=     dataset
				lowerCAmelCase_  :				Any   							=     dataset_split
				lowerCAmelCase_  :				Optional[Any]   							=     index_name

				lowerCAmelCase_  :				Optional[Any]   							=     retrieval_vector_size
				lowerCAmelCase_  :				Dict   							=     retrieval_batch_size
				lowerCAmelCase_  :				str   							=     passages_path
				lowerCAmelCase_  :				int   							=     index_path
				lowerCAmelCase_  :				Any   							=     use_dummy_dataset

				lowerCAmelCase_  :				str   							=     output_retrieved

				lowerCAmelCase_  :				List[str]   							=     do_deduplication

				lowerCAmelCase_  :				Any   							=     use_cache

				if self.forced_eos_token_id is None:
						lowerCAmelCase_  :				str   							=     getattr(self.generator		,     "forced_eos_token_id"		,     UpperCamelCase_      )





		@classmethod
		def   lowerCamelCase			(  cls				:      Optional[int]		,     a_				:      Dict		,     a_				:      Any		,     **a_				:      Optional[Any]      ):
				return cls(question_encoder=question_encoder_config.to_dict()		,     generator=generator_config.to_dict()		,     **UpperCamelCase_      )





		def   lowerCamelCase			(  self				:      List[Any]      ):
				lowerCAmelCase_  :				str   							=     copy.deepcopy(self.__dict__      )
				lowerCAmelCase_  :				int   							=     self.question_encoder.to_dict()
				lowerCAmelCase_  :				Tuple   							=     self.generator.to_dict()
				lowerCAmelCase_  :				List[str]   							=     self.__class__.model_type
				return output


"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


UpperCamelCase__          =	{
    'configuration_mega': ['MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MegaConfig', 'MegaOnnxConfig'],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__          =	[
        'MEGA_PRETRAINED_MODEL_ARCHIVE_LIST',
        'MegaForCausalLM',
        'MegaForMaskedLM',
        'MegaForMultipleChoice',
        'MegaForQuestionAnswering',
        'MegaForSequenceClassification',
        'MegaForTokenClassification',
        'MegaModel',
        'MegaPreTrainedModel',
    ]

if TYPE_CHECKING:
    from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_mega import (
            MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
            MegaForCausalLM,
            MegaForMaskedLM,
            MegaForMultipleChoice,
            MegaForQuestionAnswering,
            MegaForSequenceClassification,
            MegaForTokenClassification,
            MegaModel,
            MegaPreTrainedModel,
        )

else:
    import sys

    UpperCamelCase__          =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

