


import functools
from contextlib import contextmanager

import bert_score
from packaging import version

import datasets


@contextmanager
def 					__lowerCAmelCase    (    ) ->						str:
				def filter_log(a__						):
								return False if "This IS expected if you are initializing" in record.msg else True

				__a    							=					datasets.utils.logging.get_logger('''transformers.modeling_utils'''						)
				logger.addFilter(a__						)
				try:
								yield
				finally:
								logger.removeFilter(a__						)


A  :			Tuple     				=				'\\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'

A  :			Optional[int]     				=				'\\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'

A  :			Dict     				=				'\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     __A(				datasets.Metric    ):




				def        SCREAMING_SNAKE_CASE_	(  self       )					->   str:


								'''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        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case	,  _snake_case	,  _snake_case=None	,  _snake_case=None	,  _snake_case=None	,  _snake_case=False	,  _snake_case=False	,  _snake_case=None	,  _snake_case=64	,  _snake_case=4	,  _snake_case=False	,  _snake_case=False	,  _snake_case=None	,  _snake_case=False	,  )					->   Dict:


								'''simple docstring'''




								__a    							=					bert_score.utils.get_hash
								__a    							=					bert_score.BERTScorer

								if version.parse(bert_score.__version__       ) >= version.parse('''0.3.10'''       ):
												__a    							=					functools.partial(_snake_case	,  use_fast_tokenizer=_snake_case       )
												__a    							=					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    							=					bert_score.utils.langamodel[lang.lower()]

								if num_layers is None:
												__a    							=					bert_score.utils.modelalayers[model_type]

								__a    							=					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    							=					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)							,  (__a)							,  (__a))    							=					self.cached_bertscorer.score(
								    cands=_snake_case	,  refs=_snake_case	,  verbose=_snake_case	,  batch_size=_snake_case	,  )
								__a    							=					{
								    '''precision''': P.tolist(),
								    '''recall''': R.tolist(),
								    '''f1''': F.tolist(),
								    '''hashcode''': hashcode,
								}
								return output_dict




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case=None	,  _snake_case=None	,  **_snake_case       )					->   Tuple:


								'''simple docstring'''




								if references is not None:
												__a    							=					[[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        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case=None	,  _snake_case=None	,  **_snake_case       )					->   Union[str, Any]:


								'''simple docstring'''




								if isinstance(_snake_case	,  _snake_case       ):
												__a    							=					[reference]
								super().add(prediction=_snake_case	,  reference=_snake_case	,  **_snake_case       )

import math
from collections import OrderedDict

import torch
from packaging import version
from torch import Tensor, nn

from .utils import logging


A  :			List[str]     				=				logging.get_logger(__name__)







class     __A(				nn.Module    ):




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


								'''simple docstring'''




								super().__init__()
								if version.parse(torch.__version__       ) < version.parse('''1.12.0'''       ):
												raise ImportError(
												    F"""You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use """
												    '''PytorchGELUTanh. Please upgrade torch.'''       )




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return nn.functional.gelu(_snake_case	,  approximate='''tanh'''       )







class     __A(				nn.Module    ):




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi       ) * (input + 0.04_4715 * torch.pow(_snake_case	,  3.0       ))       ))







class     __A(				nn.Module    ):




				def __init__(  self	,  _snake_case = False       )					->   Tuple:


								'''simple docstring'''




								super().__init__()
								if use_gelu_python:
												__a    							=					self._gelu_python
								else:
												__a    							=					nn.functional.gelu




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0       )       ))




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return self.act(_snake_case       )







class     __A(				nn.Module    ):




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return 0.5 * input * (1.0 + torch.tanh(input * 0.79_7884_5608 * (1.0 + 0.04_4715 * input * input)       ))







class     __A(				nn.Module    ):




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return input * torch.sigmoid(1.702 * input       )







class     __A(				nn.Module    ):




				def __init__(  self	,  _snake_case	,  _snake_case       )					->   Optional[int]:


								'''simple docstring'''




								if min > max:
												raise ValueError(F"""min should be < max (got min: {min}, max: {max})"""       )

								super().__init__()
								__a    							=					min
								__a    							=					max




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return torch.clip(gelu(_snake_case       )	,  self.min	,  self.max       )







class     __A(				nn.Module    ):




				def __init__(  self       )					->   str:


								'''simple docstring'''




								super().__init__()
								__a    							=					math.sqrt(2 / math.pi       )




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.04_4715 * torch.pow(_snake_case	,  3       ))       ))







class     __A(				nn.Module    ):




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return nn.functional.silu(_snake_case       )







class     __A(				nn.Module    ):




				def __init__(  self       )					->   List[Any]:


								'''simple docstring'''




								super().__init__()
								if version.parse(torch.__version__       ) < version.parse('''1.9.0'''       ):
												__a    							=					self._mish_python
								else:
												__a    							=					nn.functional.mish




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return input * torch.tanh(nn.functional.softplus(_snake_case       )       )




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return self.act(_snake_case       )







class     __A(				nn.Module    ):




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Tensor:


								'''simple docstring'''




								return input







class     __A(				nn.Module    ):




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case	,  _snake_case=0.70_7107	,  _snake_case=0.28_2095       )					->   int:


								'''simple docstring'''




								__a    							=					(input - mu).div(sigma * math.sqrt(2.0       )       )
								return 0.5 * (1.0 + torch.erf(_snake_case       ))







class     __A(				nn.Module    ):




				def        SCREAMING_SNAKE_CASE_	(  self	,  _snake_case       )					->   Any:


								'''simple docstring'''




								__a    							=					nn.functional.relu(_snake_case       )
								__a    							=					torch.square(_snake_case       )
								return squared







class     __A(				a    ):




				def __getitem__(  self	,  _snake_case       )					->   Dict:


								'''simple docstring'''




								__a    							=					super().__getitem__(_snake_case       )
								__a							,  __a    							=					content if isinstance(_snake_case	,  _snake_case       ) else (content, {})
								return cls(**_snake_case       )



A  :			str     				=				{
    'gelu': GELUActivation,
    'gelu_10': (ClippedGELUActivation, {'min': -1_0, 'max': 1_0}),
    'gelu_fast': FastGELUActivation,
    'gelu_new': NewGELUActivation,
    'gelu_python': (GELUActivation, {'use_gelu_python': True}),
    'gelu_pytorch_tanh': PytorchGELUTanh,
    'gelu_accurate': AccurateGELUActivation,
    'laplace': LaplaceActivation,
    'linear': LinearActivation,
    'mish': MishActivation,
    'quick_gelu': QuickGELUActivation,
    'relu': nn.ReLU,
    'relu2': ReLUSquaredActivation,
    'relu6': nn.ReLUa,
    'sigmoid': nn.Sigmoid,
    'silu': SiLUActivation,
    'swish': SiLUActivation,
    'tanh': nn.Tanh,
}
A  :			Any     				=				ClassInstantier(ACTaCLS)


def 					__lowerCAmelCase    (    a__						) ->						Optional[int]:
				if activation_string in ACTaFN:
								return ACTaFN[activation_string]
				else:
								raise KeyError(F"""function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()						)}"""						)


# For backwards compatibility with: from activations import gelu_python
A  :			Optional[Any]     				=				get_activation('gelu_python')
A  :			str     				=				get_activation('gelu_new')
A  :			Any     				=				get_activation('gelu')
A  :			int     				=				get_activation('gelu_fast')
A  :			Any     				=				get_activation('quick_gelu')
A  :			int     				=				get_activation('silu')
A  :			List[str]     				=				get_activation('mish')






A  :			Dict     				=				get_activation('linear')