






import datasets


lowerCamelCase : int						   =       '''\
@InProceedings{conneau2018xnli,
  author = \"Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin\",
  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",
  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing\",
  year = \"2018\",
  publisher = \"Association for Computational Linguistics\",
  location = \"Brussels, Belgium\",
}
'''

lowerCamelCase : Optional[Any]						   =       '''\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
'''

lowerCamelCase : Tuple						   =       '''
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    \'accuracy\': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}
'''
def       snake_case_		(     lowerCAmelCase_       :						Tuple       ,       lowerCAmelCase_       :						Union[str, Any]      ):
							return (preds == labels).mean()



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

					'''simple docstring'''

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


												"""simple docstring"""

												return datasets.MetricInfo(
												    description=_DESCRIPTION		,     citation=_CITATION		,     inputs_description=_KWARGS_DESCRIPTION		,     features=datasets.Features(
												        {
												            """predictions""": datasets.Value("""int64""" if self.config_name != """sts-b""" else """float32"""							),
												            """references""": datasets.Value("""int64""" if self.config_name != """sts-b""" else """float32"""							),
												        }							)		,     codebase_urls=[]		,     reference_urls=[]		,     format="""numpy"""		,     )



					def       lowerCAmelCase				(  self				:	List[str]		,     __a				:	Dict		,     __a				:	List[str]							)			->  Optional[Any]:


												"""simple docstring"""

												return {"accuracy": simple_accuracy(__lowerCamelCase		,     __lowerCamelCase							)}












from __future__ import annotations
def       snake_case_		(     lowerCAmelCase_       :						list[int]      ):
							if not nums:
														return 0
							__lowercase      :							Tuple				=     nums[0]
							__lowercase      :							Tuple				=     0
							for num in nums[1:]:
														__lowercase			,			__lowercase      :							List[str]				=     (
														    max_excluding + num,
														    max(lowerCAmelCase_       ,       lowerCAmelCase_      ),
														)
							return max(lowerCAmelCase_       ,       lowerCAmelCase_      )


if __name__ == "__main__":
	import doctest

	doctest.testmod()