



"""simple docstring"""


import logging
import random

import ray

from transformers import RagConfig, RagRetriever, RagTokenizer
from transformers.models.rag.retrieval_rag import CustomHFIndex


snake_case_								=			logging.getLogger(__name__)







class  A_     :



						"""simple docstring"""






						def __init__(   self					:Dict   )							->     List[str]:
												UpperCAmelCase			 =					False






						def       UpperCAmelCase__	(   self					:Optional[int]  ,    lowercase_					:List[str]  ,    lowercase_					:Union[str, Any]  ,    lowercase_					:int  ,    lowercase_					:Tuple   )							->     str:
												if not self.initialized:
																		UpperCAmelCase			 =					RagRetriever(
																		    lowercase_  ,    question_encoder_tokenizer=lowercase_  ,    generator_tokenizer=lowercase_  ,    index=lowercase_  ,    init_retrieval=lowercase_  ,    )
																		UpperCAmelCase			 =					True






						def       UpperCAmelCase__	(   self					:Tuple   )							->     Tuple:
												self.retriever.index.init_index()






						def       UpperCAmelCase__	(   self					:List[Any]   )							->     str:
												# delete the old self.retriever object before assigning the new index
												del self.retriever
												UpperCAmelCase			 =					False






						def       UpperCAmelCase__	(   self					:Union[str, Any]  ,    lowercase_					:int  ,    lowercase_					:Dict   )							->     str:
												UpperCAmelCase ,       UpperCAmelCase			 =					self.retriever._main_retrieve(lowercase_  ,    lowercase_   )
												UpperCAmelCase			 =					self.retriever.index.get_doc_dicts(lowercase_   )
												return doc_ids, retrieved_doc_embeds, doc_dicts







class  A_     (	SCREAMING_SNAKE_CASE_							):



						"""simple docstring"""






						def __init__(   self					:List[Any]  ,    lowercase_					:Any  ,    lowercase_					:str  ,    lowercase_					:List[Any]  ,    lowercase_					:Tuple  ,    lowercase_					:Dict=None   )							->     Optional[Any]:
												if index is not None and index.is_initialized() and len(lowercase_   ) > 0:
																		raise ValueError(
																		    'When using Ray for distributed fine-tuning, '
																		    'you\'ll need to provide the paths instead, '
																		    'as the dataset and the index are loaded '
																		    'separately. More info in examples/rag/use_own_knowledge_dataset.py '   )

												super().__init__(
												    lowercase_  ,    question_encoder_tokenizer=lowercase_  ,    generator_tokenizer=lowercase_  ,    index=lowercase_  ,    init_retrieval=lowercase_  ,    )

												UpperCAmelCase			 =					retrieval_workers
												UpperCAmelCase			 =					question_encoder_tokenizer
												UpperCAmelCase			 =					generator_tokenizer
												if len(self.retrieval_workers   ) > 0:
																		ray.get(
																		    [
																		        worker.create_rag_retriever.remote(lowercase_  ,    lowercase_  ,    lowercase_  ,    lowercase_   )
																		        for worker in self.retrieval_workers
																		    ]   )






						def       UpperCAmelCase__	(   self					:Dict   )							->     List[Any]:
												logger.info('initializing retrieval'   )

												if len(self.retrieval_workers   ) > 0:
																		ray.get([worker.init_retrieval.remote() for worker in self.retrieval_workers]   )
												else:
																		# Non-distributed training. Load index into this same process.
																		self.index.init_index()






						def       UpperCAmelCase__	(   self					:Optional[Any]  ,    lowercase_					:int  ,    lowercase_					:Union[str, Any]   )							->     Tuple:
												if len(self.retrieval_workers   ) > 0:
																		# Select a random retrieval actor.
																		UpperCAmelCase			 =					self.retrieval_workers[random.randint(0  ,    len(self.retrieval_workers   ) - 1   )]
																		UpperCAmelCase ,       UpperCAmelCase ,       UpperCAmelCase			 =					ray.get(
																		    random_worker.retrieve.remote(lowercase_  ,    lowercase_   )   )
												else:
																		UpperCAmelCase ,       UpperCAmelCase			 =					self._main_retrieve(lowercase_  ,    lowercase_   )
																		UpperCAmelCase			 =					self.index.get_doc_dicts(lowercase_   )
												return retrieved_doc_embeds, doc_ids, doc_dicts






						@classmethod
						def       UpperCAmelCase__	(   cls					:Dict  ,    lowercase_					:Any  ,    lowercase_					:Dict=None  ,    **lowercase_					:List[str]   )							->     str:
												return super(lowercase_  ,    cls   ).get_tokenizers(lowercase_  ,    lowercase_  ,    **lowercase_   )






						@classmethod
						def       UpperCAmelCase__	(   cls					:Union[str, Any]  ,    lowercase_					:int  ,    lowercase_					:Any  ,    lowercase_					:List[str]=None  ,    **lowercase_					:int   )							->     int:
												UpperCAmelCase			 =					kwargs.pop('config'  ,    lowercase_   ) or RagConfig.from_pretrained(lowercase_  ,    **lowercase_   )
												UpperCAmelCase			 =					RagTokenizer.from_pretrained(lowercase_  ,    config=lowercase_   )
												UpperCAmelCase			 =					rag_tokenizer.question_encoder
												UpperCAmelCase			 =					rag_tokenizer.generator

												if indexed_dataset is not None:
																		UpperCAmelCase			 =					'custom'
																		UpperCAmelCase			 =					CustomHFIndex(config.retrieval_vector_size  ,    lowercase_   )
												else:
																		UpperCAmelCase			 =					cls._build_index(lowercase_   )

												return cls(
												    lowercase_  ,    question_encoder_tokenizer=lowercase_  ,    generator_tokenizer=lowercase_  ,    retrieval_workers=lowercase_  ,    index=lowercase_  ,    )






						def       UpperCAmelCase__	(   self					:Optional[Any]   )							->     Dict:
												logger.info('re-loading the new dataset with embeddings'   )
												# access from the training loop

												ray.get([worker.clear_object.remote() for worker in self.retrieval_workers]   )

												# build the index object again
												UpperCAmelCase			 =					self._build_index(self.config   )

												ray.get(
												    [
												        worker.create_rag_retriever.remote(
												            self.config  ,    self.question_encoder_tokenizer  ,    self.generator_tokenizer  ,    lowercase_   )
												        for worker in self.retrieval_workers
												    ]   )








from math import factorial




def        __UpperCamelCase     (      _A					:							Union[str, Any]      ,  _A					:							Tuple		)				->Any:



							"""simple docstring"""
							return factorial(_A		) / (factorial(_A		) * factorial(n - r		))




def        __UpperCamelCase     (      )				->Any:



							"""simple docstring"""
							lowerCamelCase_								=0

							for i in range(1      ,  101		):
														for j in range(1      ,  i + 1		):
																					if combinations(_A      ,  _A		) > 1E6:
																												total += 1
							return total


if __name__ == "__main__":
	print(solution())
