





'''simple docstring'''




import copy

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


_SCREAMING_SNAKE_CASE							     =			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"""






     snake_case_						      =   "rag"
     snake_case_						      =   True



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

        from ..auto.configuration_auto import AutoConfig

        snake_case 						=   AutoConfig.for_model(__snake_case   ,       **__snake_case						)
        snake_case 						=   AutoConfig.for_model(__snake_case   ,       **__snake_case						)

        snake_case 						=   reduce_loss
        snake_case 						=   label_smoothing
        snake_case 						=   exclude_bos_score
        snake_case 						=   do_marginalize

        snake_case 						=   title_sep
        snake_case 						=   doc_sep
        snake_case 						=   n_docs
        snake_case 						=   max_combined_length

        snake_case 						=   dataset
        snake_case 						=   dataset_split
        snake_case 						=   index_name

        snake_case 						=   retrieval_vector_size
        snake_case 						=   retrieval_batch_size
        snake_case 						=   passages_path
        snake_case 						=   index_path
        snake_case 						=   use_dummy_dataset

        snake_case 						=   output_retrieved

        snake_case 						=   do_deduplication

        snake_case 						=   use_cache

        if self.forced_eos_token_id is None:
           snake_case 						=   getattr(self.generator   ,       """forced_eos_token_id"""   ,       __snake_case						)



     @classmethod
     def      lowerCAmelCase			(   cls							:			Any   ,       __snake_case							:			Tuple   ,       __snake_case							:			List[str]   ,       **__snake_case							:			Optional[Any]						)->	PretrainedConfig:
        return cls(question_encoder=question_encoder_config.to_dict()   ,       generator=generator_config.to_dict()   ,       **__snake_case						)



     def      lowerCAmelCase			(   self							:			Optional[Any]						)->	str:
        snake_case 						=   copy.deepcopy(self.__dict__						)
        snake_case 						=   self.question_encoder.to_dict()
        snake_case 						=   self.generator.to_dict()
        snake_case 						=   self.__class__.model_type
        return output







'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_					=   {
    "configuration_clap": [
        "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
        "ClapAudioConfig",
        "ClapConfig",
        "ClapTextConfig",
    ],
    "processing_clap": ["ClapProcessor"],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_					=   [
      "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST",
      "ClapModel",
      "ClapPreTrainedModel",
      "ClapTextModel",
      "ClapTextModelWithProjection",
      "ClapAudioModel",
      "ClapAudioModelWithProjection",
  ]
  UpperCAmelCase_					=   ["ClapFeatureExtractor"]

if TYPE_CHECKING:
  from .configuration_clap import (
      CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
      ClapAudioConfig,
      ClapConfig,
      ClapTextConfig,
  )
  from .processing_clap import ClapProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_clap import ClapFeatureExtractor
    from .modeling_clap import (
        CLAP_PRETRAINED_MODEL_ARCHIVE_LIST,
        ClapAudioModel,
        ClapAudioModelWithProjection,
        ClapModel,
        ClapPreTrainedModel,
        ClapTextModel,
        ClapTextModelWithProjection,
    )


else:
  import sys

  UpperCAmelCase_					=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



