






import datasets


__UpperCamelCase      :      Dict     						=						"""\
@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\",
}
"""

__UpperCamelCase      :      Dict     						=						"""\
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).
"""

__UpperCamelCase      :      Any     						=						"""
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				,  lowerCamelCase					):




	'''simple docstring'''







	return (preds == labels).mean()




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







	def  _a   (  self      :							Tuple			)		-> Optional[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  _a   (  self      :							Any       ,				_lowerCAmelCase      :							Any       ,				_lowerCAmelCase      :							Optional[int]			)		-> List[Any]:
		"""simple docstring"""







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










from __future__ import annotations





def 				snake_case  (     lowerCamelCase					):




	'''simple docstring'''







	if not nums:
		return 0
	__lowercase             =  nums[0]
	__lowercase             =  0
	for num in nums[1:]:
		__lowercase       ,						__lowercase             =  (
		    max_excluding + num,
		    max(lowerCamelCase				,  lowerCamelCase					),
		)
	return max(lowerCamelCase				,  lowerCamelCase					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()

