






'''simple docstring'''
import copy

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


a_ 		=       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(__SCREAMING_SNAKE_CASE )
class    __SCREAMING_SNAKE_CASE					(	__SCREAMING_SNAKE_CASE ):
 snake_case_     							=							"""rag"""
 snake_case_     							=							True




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

       from ..auto.configuration_auto import AutoConfig

       SCREAMING_SNAKE_CASE__   : Union[str, Any]													=AutoConfig.for_model(_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE					)
       SCREAMING_SNAKE_CASE__   : Optional[int]													=AutoConfig.for_model(_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE					)

       SCREAMING_SNAKE_CASE__   : Union[str, Any]													=reduce_loss
       SCREAMING_SNAKE_CASE__   : int													=label_smoothing
       SCREAMING_SNAKE_CASE__   : Union[str, Any]													=exclude_bos_score
       SCREAMING_SNAKE_CASE__   : List[str]													=do_marginalize

       SCREAMING_SNAKE_CASE__   : Optional[int]													=title_sep
       SCREAMING_SNAKE_CASE__   : Tuple													=doc_sep
       SCREAMING_SNAKE_CASE__   : Optional[Any]													=n_docs
       SCREAMING_SNAKE_CASE__   : List[str]													=max_combined_length

       SCREAMING_SNAKE_CASE__   : Optional[int]													=dataset
       SCREAMING_SNAKE_CASE__   : str													=dataset_split
       SCREAMING_SNAKE_CASE__   : str													=index_name

       SCREAMING_SNAKE_CASE__   : str													=retrieval_vector_size
       SCREAMING_SNAKE_CASE__   : Union[str, Any]													=retrieval_batch_size
       SCREAMING_SNAKE_CASE__   : Optional[Any]													=passages_path
       SCREAMING_SNAKE_CASE__   : List[str]													=index_path
       SCREAMING_SNAKE_CASE__   : str													=use_dummy_dataset

       SCREAMING_SNAKE_CASE__   : Optional[int]													=output_retrieved

       SCREAMING_SNAKE_CASE__   : int													=do_deduplication

       SCREAMING_SNAKE_CASE__   : List[str]													=use_cache

       if self.forced_eos_token_id is None:
             SCREAMING_SNAKE_CASE__   : Optional[Any]													=getattr(self.generator    ,					'''forced_eos_token_id'''    ,					_SCREAMING_SNAKE_CASE					)




 @classmethod
 def    __magic_name__		(					cls		:							List[str]    ,					__lowercase		:							PretrainedConfig    ,					__lowercase		:							PretrainedConfig    ,					**__lowercase		:							Tuple					)		->  PretrainedConfig:
       return cls(question_encoder=question_encoder_config.to_dict()    ,					generator=generator_config.to_dict()    ,					**_SCREAMING_SNAKE_CASE					)




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




"""simple docstring"""






import gc
import threading
import time

import psutil
import torch



class 			A__   :




	'''simple docstring'''





	def __init__(     self:		str)				->       Optional[Any]:

				"""simple docstring"""

				__lowerCAmelCase      :  Optional[Any]												=       psutil.Process()
				__lowerCAmelCase      :  str												=       False

	def 							_SCREAMING_SNAKE_CASE   (     self:		int)				->       Optional[int]:

				"""simple docstring"""

				__lowerCAmelCase      :  Optional[Any]												=       -1

				while True:
							__lowerCAmelCase      :  str												=       max(self.process.memory_info().rss       ,			self.cpu_memory_peak)

							# can't sleep or will not catch the peak right (this comment is here on purpose)
							if not self.peak_monitoring:
										break

	def 							_SCREAMING_SNAKE_CASE   (     self:		Tuple)				->       int:

				"""simple docstring"""

				__lowerCAmelCase      :  List[str]												=       True
				__lowerCAmelCase      :  str												=       threading.Thread(target=self.peak_monitor)
				__lowerCAmelCase      :  Tuple												=       True
				self.thread.start()







	def 							_SCREAMING_SNAKE_CASE   (     self:		Optional[Any])				->       List[str]:

				"""simple docstring"""

				__lowerCAmelCase      :  Tuple												=       False
				self.thread.join()
				return self.cpu_memory_peak






__snake_case							:   Tuple      =    PeakCPUMemory()


def 			_lowercase				(  )						->   str:
			# Time
			__lowerCAmelCase      :  str												=       {"time": time.time()}

			gc.collect()
			torch.cuda.empty_cache()

			# CPU mem
			__lowerCAmelCase      :  Optional[Any]												=       psutil.Process().memory_info().rss
			cpu_peak_tracker.start()

			# GPU mem
			for i in range(torch.cuda.device_count()	):
						__lowerCAmelCase      :  Union[str, Any]												=       torch.cuda.memory_allocated(__snake_case	)
			torch.cuda.reset_peak_memory_stats()

			return measures


def 			_lowercase				(  __snake_case	)						->   Optional[Any]:
			# Time
			__lowerCAmelCase      :  str												=       {"time": time.time() - start_measures["time"]}

			gc.collect()
			torch.cuda.empty_cache()

			# CPU mem
			__lowerCAmelCase      :  str												=       (psutil.Process().memory_info().rss - start_measures["cpu"]) / 2**20
			__lowerCAmelCase      :  List[str]												=       (cpu_peak_tracker.stop() - start_measures["cpu"]) / 2**20

			# GPU mem
			for i in range(torch.cuda.device_count()	):
						__lowerCAmelCase      :  Union[str, Any]												=       (torch.cuda.memory_allocated(__snake_case	) - start_measures[str(__snake_case	)]) / 2**20
						__lowerCAmelCase      :  Any												=       (torch.cuda.max_memory_allocated(__snake_case	) - start_measures[str(__snake_case	)]) / 2**20

			return measures





def 			_lowercase				(  __snake_case					,__snake_case	)						->   Dict:
			print(F"""{description}:"""	)
			print(F"""- Time: {measures['time']:.2f}s"""	)
			for i in range(torch.cuda.device_count()	):
						print(F"""- GPU {i} allocated: {measures[str(__snake_case	)]:.2f}MiB"""	)
						__lowerCAmelCase      :  Optional[Any]												=       measures[F"""{i}-peak"""]
						print(F"""- GPU {i} peak: {peak:.2f}MiB"""	)
			print(F"""- CPU RAM allocated: {measures['cpu']:.2f}MiB"""	)
			print(F"""- CPU RAM peak: {measures['cpu-peak']:.2f}MiB"""	)