






'''simple docstring'''



import datasets


__UpperCamelCase   :							Optional[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\",
}
"""

__UpperCamelCase   :							List[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).
"""

__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  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						Optional[Any],       SCREAMING_SNAKE_CASE__:						Any     )	->      Optional[int]:

   """simple docstring"""
   return (preds == labels).mean()



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




      def 			__UpperCamelCase				(	self   )				->str:



         '''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 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase   )				->int:



         '''simple docstring'''
         return {"accuracy": simple_accuracy(lowerCamelCase			, lowerCamelCase   )}







'''simple docstring'''



from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__UpperCamelCase   :							Dict         =   logging.get_logger(__name__)
class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):
      __a	       =["pixel_values"]




      def __init__(	self			, lowerCamelCase = True			, lowerCamelCase = 32			, lowerCamelCase=PILImageResampling.BILINEAR			, lowerCamelCase = True			, **lowerCamelCase			, )				->None:



         '''simple docstring'''
         __a					  =     do_resize
         __a					  =     do_rescale
         __a					  =     size_divisor
         __a					  =     resample
         super().__init__(**lowerCamelCase   )




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase = None			, **lowerCamelCase   )				->np.ndarray:



         '''simple docstring'''
         __a  ,      __a					  =     get_image_size(lowerCamelCase   )
         # Rounds the height and width down to the closest multiple of size_divisor
         __a					  =     height // size_divisor * size_divisor
         __a					  =     width // size_divisor * size_divisor
         __a					  =     resize(lowerCamelCase			, (new_h, new_w)			, resample=lowerCamelCase			, data_format=lowerCamelCase			, **lowerCamelCase   )
         return image




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase = None			, **lowerCamelCase   )				->np.ndarray:



         '''simple docstring'''
         return rescale(image=lowerCamelCase			, scale=lowerCamelCase			, data_format=lowerCamelCase			, **lowerCamelCase   )






      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase = None			, lowerCamelCase = None			, lowerCamelCase=None			, lowerCamelCase = None			, lowerCamelCase = None			, lowerCamelCase = ChannelDimension.FIRST			, **lowerCamelCase			, )				->BatchFeature:



         '''simple docstring'''
         __a					  =     do_resize if do_resize is not None else self.do_resize
         __a					  =     do_rescale if do_rescale is not None else self.do_rescale
         __a					  =     size_divisor if size_divisor is not None else self.size_divisor
         __a					  =     resample if resample is not None else self.resample

         if do_resize and size_divisor is None:
            raise ValueError('size_divisor is required for resizing'   )

         __a					  =     make_list_of_images(lowerCamelCase   )

         if not valid_images(lowerCamelCase   ):
            raise ValueError('Invalid image(s)'   )

         # All transformations expect numpy arrays.
         __a					  =     [to_numpy_array(lowerCamelCase   ) for img in images]

         if do_resize:
            __a					  =     [self.resize(lowerCamelCase			, size_divisor=lowerCamelCase			, resample=lowerCamelCase   ) for image in images]

         if do_rescale:
            __a					  =     [self.rescale(lowerCamelCase			, scale=1 / 255   ) for image in images]

         __a					  =     [to_channel_dimension_format(lowerCamelCase			, lowerCamelCase   ) for image in images]

         __a					  =     {'pixel_values': images}
         return BatchFeature(data=lowerCamelCase			, tensor_type=lowerCamelCase   )