
'''simple docstring'''





import functools
from contextlib import contextmanager

import bert_score
from packaging import version

import datasets





@contextmanager
def 							_lowerCamelCase			(					):



				'''simple docstring'''







				def filter_log(lowerCamelCase_:  Optional[Any]		):
								return False if "This IS expected if you are initializing" in record.msg else True

				A     :  List[str]   =				datasets.utils.logging.get_logger('''transformers.modeling_utils'''		)
				logger.addFilter(lowercase__		)
				try:
								yield
				finally:
								logger.removeFilter(lowercase__		)


UpperCamelCase_  =	"\\n@inproceedings{bert-score,\n  title={BERTScore: Evaluating Text Generation with BERT},\n  author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},\n  booktitle={International Conference on Learning Representations},\n  year={2020},\n  url={https://openreview.net/forum?id=SkeHuCVFDr}\n}\n"

UpperCamelCase_  =	"\\nBERTScore leverages the pre-trained contextual embeddings from BERT and matches words in candidate and reference\nsentences by cosine similarity.\nIt has been shown to correlate with human judgment on sentence-level and system-level evaluation.\nMoreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language\ngeneration tasks.\n\nSee the project's README at https://github.com/Tiiiger/bert_score#readme for more information.\n"

UpperCamelCase_  =	"\nBERTScore Metrics with the hashcode from a source against one or more references.\n\nArgs:\n    predictions (list of str): Prediction/candidate sentences.\n    references (list of str or list of list of str): Reference sentences.\n    lang (str): Language of the sentences; required (e.g. 'en').\n    model_type (str): Bert specification, default using the suggested\n        model for the target language; has to specify at least one of\n        `model_type` or `lang`.\n    num_layers (int): The layer of representation to use,\n        default using the number of layers tuned on WMT16 correlation data.\n    verbose (bool): Turn on intermediate status update.\n    idf (bool or dict): Use idf weighting; can also be a precomputed idf_dict.\n    device (str): On which the contextual embedding model will be allocated on.\n        If this argument is None, the model lives on cuda:0 if cuda is available.\n    nthreads (int): Number of threads.\n    batch_size (int): Bert score processing batch size,\n        at least one of `model_type` or `lang`. `lang` needs to be\n        specified when `rescale_with_baseline` is True.\n    rescale_with_baseline (bool): Rescale bertscore with pre-computed baseline.\n    baseline_path (str): Customized baseline file.\n    use_fast_tokenizer (bool): `use_fast` parameter passed to HF tokenizer. New in version 0.3.10.\n\nReturns:\n    precision: Precision.\n    recall: Recall.\n    f1: F1 score.\n    hashcode: Hashcode of the library.\n\nExamples:\n\n    >>> predictions = [\"hello there\", \"general kenobi\"]\n    >>> references = [\"hello there\", \"general kenobi\"]\n    >>> bertscore = datasets.load_metric(\"bertscore\")\n    >>> results = bertscore.compute(predictions=predictions, references=references, lang=\"en\")\n    >>> print([round(v, 2) for v in results[\"f1\"]])\n    [1.0, 1.0]\n"






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION,    _KWARGS_DESCRIPTION							)
class     _SCREAMING_SNAKE_CASE							(		datasets.Metric							):





				def        _UpperCAmelCase						(		self :		Optional[Any]							):


								"""simple docstring"""

								return datasets.MetricInfo(
								    description=_DESCRIPTION					,      citation=_CITATION					,      homepage='''https://github.com/Tiiiger/bert_score'''					,      inputs_description=_KWARGS_DESCRIPTION					,      features=datasets.Features(
								        {
								            '''predictions''': datasets.Value('''string'''					,      id='''sequence'''							),
								            '''references''': datasets.Sequence(datasets.Value('''string'''					,      id='''sequence'''							)					,      id='''references'''							),
								        }							)					,      codebase_urls=['''https://github.com/Tiiiger/bert_score''']					,      reference_urls=[
								        '''https://github.com/Tiiiger/bert_score''',
								        '''https://arxiv.org/abs/1904.09675''',
								    ]					,      )





				def        _UpperCAmelCase						(		self :		Any					,      snake_case_ :		List[str]					,      snake_case_ :		str					,      snake_case_ :		Dict=None					,      snake_case_ :		str=None					,      snake_case_ :		Any=None					,      snake_case_ :		Any=False					,      snake_case_ :		List[Any]=False					,      snake_case_ :		Optional[Any]=None					,      snake_case_ :		Optional[int]=64					,      snake_case_ :		int=4					,      snake_case_ :		Tuple=False					,      snake_case_ :		List[Any]=False					,      snake_case_ :		Optional[Any]=None					,      snake_case_ :		int=False					,      ):


								"""simple docstring"""

								A     :  Any   =				bert_score.utils.get_hash
								A     :  List[str]   =				bert_score.BERTScorer

								if version.parse(bert_score.__version__							) >= version.parse('''0.3.10'''							):
												A     :  List[str]   =				functools.partial(snake_case_					,      use_fast_tokenizer=snake_case_							)
												A     :  List[str]   =				functools.partial(snake_case_					,      use_fast_tokenizer=snake_case_							)
								elif use_fast_tokenizer:
												raise ImportWarning(
												    '''To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of `bert-score` doesn\'t match this condition.\n'''
												    '''You can install it with `pip install \"bert-score>=0.3.10\"`.'''							)

								if model_type is None:
												assert lang is not None, "either lang or model_type should be specified"
												A     :  Optional[Any]   =				bert_score.utils.langamodel[lang.lower()]

								if num_layers is None:
												A     :  List[str]   =				bert_score.utils.modelalayers[model_type]

								A     :  List[Any]   =				get_hash(
								    model=snake_case_					,      num_layers=snake_case_					,      idf=snake_case_					,      rescale_with_baseline=snake_case_					,      use_custom_baseline=baseline_path is not None					,      )

								with filter_logging_context():
												if not hasattr(self					,      '''cached_bertscorer'''							) or self.cached_bertscorer.hash != hashcode:
																A     :  Union[str, Any]   =				scorer(
																    model_type=snake_case_					,      num_layers=snake_case_					,      batch_size=snake_case_					,      nthreads=snake_case_					,      all_layers=snake_case_					,      idf=snake_case_					,      device=snake_case_					,      lang=snake_case_					,      rescale_with_baseline=snake_case_					,      baseline_path=snake_case_					,      )

								(A)     :  Dict   =				self.cached_bertscorer.score(
								    cands=snake_case_					,      refs=snake_case_					,      verbose=snake_case_					,      batch_size=snake_case_					,      )
								A     :  Tuple   =				{
								    "precision": P.tolist(),
								    "recall": R.tolist(),
								    "f1": F.tolist(),
								    "hashcode": hashcode,
								}
								return output_dict





				def        _UpperCAmelCase						(		self :		str					,      snake_case_ :		Union[str, Any]=None					,      snake_case_ :		List[str]=None					,      **snake_case_ :		Optional[Any]							):


								"""simple docstring"""

								if references is not None:
												A     :  List[Any]   =				[[ref] if isinstance(snake_case_					,      snake_case_							) else ref for ref in references]
								super().add_batch(predictions=snake_case_					,      references=snake_case_					,      **snake_case_							)






				def        _UpperCAmelCase						(		self :		str					,      snake_case_ :		Union[str, Any]=None					,      snake_case_ :		str=None					,      **snake_case_ :		List[Any]							):


								"""simple docstring"""

								if isinstance(snake_case_					,      snake_case_							):
												A     :  Tuple   =				[reference]
								super().add(prediction=snake_case_					,      reference=snake_case_					,      **snake_case_							)

UpperCamelCase_  =	{
    "0": 1,
    "1": 1,
    "2": 2,
    "3": 6,
    "4": 24,
    "5": 1_20,
    "6": 7_20,
    "7": 50_40,
    "8": 4_03_20,
    "9": 36_28_80,
}

UpperCamelCase_  =	{1_45: 1_45}

UpperCamelCase_  =	{
    1_45: 0,
    1_69: 3,
    3_63_01: 3,
    14_54: 3,
    8_71: 2,
    4_53_61: 2,
    8_72: 2,
}





def 							_lowerCamelCase			(					lowerCamelCase_:  int		):



				'''simple docstring'''







				if n in CACHE_SUM_DIGIT_FACTORIALS:
								return CACHE_SUM_DIGIT_FACTORIALS[n]
				A     :  Tuple   =				sum(DIGIT_FACTORIALS[let] for let in str(lowerCamelCase_		)		)
				A     :  Dict   =				ret
				return ret





def 							_lowerCamelCase			(					lowerCamelCase_:  int				,	lowerCamelCase_:  set | None = None		):



				'''simple docstring'''







				A     :  Optional[int]   =				previous or set()
				if n in CHAIN_LENGTH_CACHE:
								return CHAIN_LENGTH_CACHE[n]
				A     :  Dict   =				sum_digit_factorials(lowerCamelCase_		)
				if next_number in previous:
								A     :  Optional[int]   =				0
								return 0
				else:
								previous.add(lowerCamelCase_		)
								A     :  str   =				1 + chain_length(lowerCamelCase_				,	lowerCamelCase_		)
								A     :  Any   =				ret
								return ret





def 							_lowerCamelCase			(					lowerCamelCase_:  int = 60				,	lowerCamelCase_:  int = 100_0000		):



				'''simple docstring'''







				return sum(1 for i in range(1				,	lowerCamelCase_		) if chain_length(lowerCamelCase_		) == num_terms		)


if __name__ == "__main__":
					print(F'''{solution() = }''')