
"""simple docstring"""

import datasets

from .evaluate import evaluate


SCREAMING_SNAKE_CASE_            =    '''\
@inproceedings{Rajpurkar2016SQuAD10,
  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},
  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},
  booktitle={EMNLP},
  year={2016}
}
'''

SCREAMING_SNAKE_CASE_            =    '''
This metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).

Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by
crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,
from the corresponding reading passage, or the question might be unanswerable.
'''

SCREAMING_SNAKE_CASE_            =    '''
Computes SQuAD scores (F1 and EM).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair as given in the references (see below)
        - \'prediction_text\': the text of the answer
    references: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair (see above),
        - \'answers\': a Dict in the SQuAD dataset format
            {
                \'text\': list of possible texts for the answer, as a list of strings
                \'answer_start\': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)
    \'f1\': The F-score of predicted tokens versus the gold answer
Examples:

    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> squad_metric = datasets.load_metric("squad")
    >>> results = squad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 100.0, \'f1\': 100.0}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,      _KWARGS_DESCRIPTION				)
class   _UpperCAmelCase				(		datasets.Metric				):




      def      a_   (				self				)    ->       int:
          return datasets.MetricInfo(
              description=_DESCRIPTION ,							citation=_CITATION ,							inputs_description=_KWARGS_DESCRIPTION ,							features=datasets.Features(
                  {
                      'predictions': {'id': datasets.Value('string'				), 'prediction_text': datasets.Value('string'				)},
                      'references': {
                          'id': datasets.Value('string'				),
                          'answers': datasets.features.Sequence(
                              {
                                  'text': datasets.Value('string'				),
                                  'answer_start': datasets.Value('int32'				),
                              }				),
                      },
                  }				) ,							codebase_urls=['https://rajpurkar.github.io/SQuAD-explorer/'] ,							reference_urls=['https://rajpurkar.github.io/SQuAD-explorer/'] ,							)




      def      a_   (				self ,							lowercase_ ,							lowercase_				)    ->       Tuple:
          UpperCAmelCase          =       {prediction['id']: prediction['prediction_text'] for prediction in predictions}
          UpperCAmelCase          =       [
              {
                  'paragraphs': [
                      {
                          'qas': [
                              {
                                  'answers': [{'text': answer_text} for answer_text in ref['answers']['text']],
                                  'id': ref['id'],
                              }
                              for ref in references
                          ]
                      }
                  ]
              }
          ]
          UpperCAmelCase          =       evaluate(dataset=lowercase_ ,							predictions=lowercase_				)
          return score





"""simple docstring"""

import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import DetaImageProcessor
class   _UpperCAmelCase				(		unittest.TestCase				):




      def __init__(				self ,							lowercase_ ,							lowercase_=7 ,							lowercase_=3 ,							lowercase_=3_0 ,							lowercase_=4_0_0 ,							lowercase_=True ,							lowercase_=None ,							lowercase_=True ,							lowercase_=[0.5, 0.5, 0.5] ,							lowercase_=[0.5, 0.5, 0.5] ,							lowercase_=True ,							lowercase_=1 / 2_5_5 ,							lowercase_=True ,							)    ->       Union[str, Any]:
          # by setting size["longest_edge"] > max_resolution we're effectively not testing this :p
          UpperCAmelCase          =       size if size is not None else {'shortest_edge': 1_8, 'longest_edge': 1_3_3_3}
          UpperCAmelCase          =       parent
          UpperCAmelCase          =       batch_size
          UpperCAmelCase          =       num_channels
          UpperCAmelCase          =       min_resolution
          UpperCAmelCase          =       max_resolution
          UpperCAmelCase          =       do_resize
          UpperCAmelCase          =       size
          UpperCAmelCase          =       do_normalize
          UpperCAmelCase          =       image_mean
          UpperCAmelCase          =       image_std
          UpperCAmelCase          =       do_rescale
          UpperCAmelCase          =       rescale_factor
          UpperCAmelCase          =       do_pad




      def      a_   (				self				)    ->       int:
          return {
              "do_resize": self.do_resize,
              "size": self.size,
              "do_normalize": self.do_normalize,
              "image_mean": self.image_mean,
              "image_std": self.image_std,
              "do_rescale": self.do_rescale,
              "rescale_factor": self.rescale_factor,
              "do_pad": self.do_pad,
          }




      def      a_   (				self ,							lowercase_ ,							lowercase_=False				)    ->       Union[str, Any]:
          if not batched:
              UpperCAmelCase          =       image_inputs[0]
              if isinstance(lowercase_ ,							Image.Image				):
                  UpperCAmelCase      ,				UpperCAmelCase          =       image.size
              else:
                  UpperCAmelCase      ,				UpperCAmelCase          =       image.shape[1], image.shape[2]
              if w < h:
                  UpperCAmelCase          =       int(self.size['shortest_edge'] * h / w				)
                  UpperCAmelCase          =       self.size['shortest_edge']
              elif w > h:
                  UpperCAmelCase          =       self.size['shortest_edge']
                  UpperCAmelCase          =       int(self.size['shortest_edge'] * w / h				)
              else:
                  UpperCAmelCase          =       self.size['shortest_edge']
                  UpperCAmelCase          =       self.size['shortest_edge']

          else:
              UpperCAmelCase          =       []
              for image in image_inputs:
                  UpperCAmelCase      ,				UpperCAmelCase          =       self.get_expected_values([image]				)
                  expected_values.append((expected_height, expected_width)				)
              UpperCAmelCase          =       max(lowercase_ ,							key=lambda lowercase_				: item[0]				)[0]
              UpperCAmelCase          =       max(lowercase_ ,							key=lambda lowercase_				: item[1]				)[1]

          return expected_height, expected_width

@require_torch
@require_vision
class   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_  ,      unittest.TestCase				):
      __SCREAMING_SNAKE_CASE :				Union[str, Any]				   =						DetaImageProcessor if is_vision_available() else None




      def      a_   (				self				)    ->       List[Any]:
          UpperCAmelCase          =       DetaImageProcessingTester(self				)




      @property
      def      a_   (				self				)    ->       Optional[Any]:
          return self.image_processor_tester.prepare_image_processor_dict()




      def      a_   (				self				)    ->       Dict:
          UpperCAmelCase          =       self.image_processing_class(**self.image_processor_dict				)
          self.assertTrue(hasattr(lowercase_ ,							'image_mean'				)				)
          self.assertTrue(hasattr(lowercase_ ,							'image_std'				)				)
          self.assertTrue(hasattr(lowercase_ ,							'do_normalize'				)				)
          self.assertTrue(hasattr(lowercase_ ,							'do_resize'				)				)
          self.assertTrue(hasattr(lowercase_ ,							'do_rescale'				)				)
          self.assertTrue(hasattr(lowercase_ ,							'do_pad'				)				)
          self.assertTrue(hasattr(lowercase_ ,							'size'				)				)




      def      a_   (				self				)    ->       int:
          UpperCAmelCase          =       self.image_processing_class.from_dict(self.image_processor_dict				)
          self.assertEqual(image_processor.size ,							{'shortest_edge': 1_8, 'longest_edge': 1_3_3_3}				)
          self.assertEqual(image_processor.do_pad ,							lowercase_				)




      def      a_   (				self				)    ->       int:
          pass




      def      a_   (				self				)    ->       Union[str, Any]:
          # Initialize image_processing
          UpperCAmelCase          =       self.image_processing_class(**self.image_processor_dict				)
          # create random PIL images
          UpperCAmelCase          =       prepare_image_inputs(self.image_processor_tester ,							equal_resolution=lowercase_				)
          for image in image_inputs:
              self.assertIsInstance(lowercase_ ,							Image.Image				)

          # Test not batched input
          UpperCAmelCase          =       image_processing(image_inputs[0] ,							return_tensors='pt'				).pixel_values

          UpperCAmelCase      ,				UpperCAmelCase          =       self.image_processor_tester.get_expected_values(lowercase_				)

          self.assertEqual(
              encoded_images.shape ,							(1, self.image_processor_tester.num_channels, expected_height, expected_width) ,							)

          # Test batched
          UpperCAmelCase      ,				UpperCAmelCase          =       self.image_processor_tester.get_expected_values(lowercase_ ,							batched=lowercase_				)

          UpperCAmelCase          =       image_processing(lowercase_ ,							return_tensors='pt'				).pixel_values
          self.assertEqual(
              encoded_images.shape ,							(
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              ) ,							)




      def      a_   (				self				)    ->       Tuple:
          # Initialize image_processing
          UpperCAmelCase          =       self.image_processing_class(**self.image_processor_dict				)
          # create random numpy tensors
          UpperCAmelCase          =       prepare_image_inputs(self.image_processor_tester ,							equal_resolution=lowercase_ ,							numpify=lowercase_				)
          for image in image_inputs:
              self.assertIsInstance(lowercase_ ,							np.ndarray				)

          # Test not batched input
          UpperCAmelCase          =       image_processing(image_inputs[0] ,							return_tensors='pt'				).pixel_values

          UpperCAmelCase      ,				UpperCAmelCase          =       self.image_processor_tester.get_expected_values(lowercase_				)

          self.assertEqual(
              encoded_images.shape ,							(1, self.image_processor_tester.num_channels, expected_height, expected_width) ,							)

          # Test batched
          UpperCAmelCase          =       image_processing(lowercase_ ,							return_tensors='pt'				).pixel_values

          UpperCAmelCase      ,				UpperCAmelCase          =       self.image_processor_tester.get_expected_values(lowercase_ ,							batched=lowercase_				)

          self.assertEqual(
              encoded_images.shape ,							(
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              ) ,							)




      def      a_   (				self				)    ->       Optional[Any]:
          # Initialize image_processing
          UpperCAmelCase          =       self.image_processing_class(**self.image_processor_dict				)
          # create random PyTorch tensors
          UpperCAmelCase          =       prepare_image_inputs(self.image_processor_tester ,							equal_resolution=lowercase_ ,							torchify=lowercase_				)
          for image in image_inputs:
              self.assertIsInstance(lowercase_ ,							torch.Tensor				)

          # Test not batched input
          UpperCAmelCase          =       image_processing(image_inputs[0] ,							return_tensors='pt'				).pixel_values

          UpperCAmelCase      ,				UpperCAmelCase          =       self.image_processor_tester.get_expected_values(lowercase_				)

          self.assertEqual(
              encoded_images.shape ,							(1, self.image_processor_tester.num_channels, expected_height, expected_width) ,							)

          # Test batched
          UpperCAmelCase          =       image_processing(lowercase_ ,							return_tensors='pt'				).pixel_values

          UpperCAmelCase      ,				UpperCAmelCase          =       self.image_processor_tester.get_expected_values(lowercase_ ,							batched=lowercase_				)

          self.assertEqual(
              encoded_images.shape ,							(
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              ) ,							)




      @slow
      def      a_   (				self				)    ->       str:
          # prepare image and target
          UpperCAmelCase          =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
          with open('./tests/fixtures/tests_samples/COCO/coco_annotations.txt' ,							'r'				) as f:
              UpperCAmelCase          =       json.loads(f.read()				)

          UpperCAmelCase          =       {'image_id': 3_9_7_6_9, 'annotations': target}

          # encode them
          UpperCAmelCase          =       DetaImageProcessor()
          UpperCAmelCase          =       image_processing(images=lowercase_ ,							annotations=lowercase_ ,							return_tensors='pt'				)

          # verify pixel values
          UpperCAmelCase          =       torch.Size([1, 3, 8_0_0, 1_0_6_6]				)
          self.assertEqual(encoding['pixel_values'].shape ,							lowercase_				)

          UpperCAmelCase          =       torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]				)
          self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3] ,							lowercase_ ,							atol=1E-4				)				)

          # verify area
          UpperCAmelCase          =       torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['area'] ,							lowercase_				)				)
          # verify boxes
          UpperCAmelCase          =       torch.Size([6, 4]				)
          self.assertEqual(encoding['labels'][0]['boxes'].shape ,							lowercase_				)
          UpperCAmelCase          =       torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0] ,							lowercase_ ,							atol=1E-3				)				)
          # verify image_id
          UpperCAmelCase          =       torch.tensor([3_9_7_6_9]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['image_id'] ,							lowercase_				)				)
          # verify is_crowd
          UpperCAmelCase          =       torch.tensor([0, 0, 0, 0, 0, 0]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd'] ,							lowercase_				)				)
          # verify class_labels
          UpperCAmelCase          =       torch.tensor([7_5, 7_5, 6_3, 6_5, 1_7, 1_7]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels'] ,							lowercase_				)				)
          # verify orig_size
          UpperCAmelCase          =       torch.tensor([4_8_0, 6_4_0]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size'] ,							lowercase_				)				)
          # verify size
          UpperCAmelCase          =       torch.tensor([8_0_0, 1_0_6_6]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['size'] ,							lowercase_				)				)




      @slow
      def      a_   (				self				)    ->       Any:
          # prepare image, target and masks_path
          UpperCAmelCase          =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
          with open('./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt' ,							'r'				) as f:
              UpperCAmelCase          =       json.loads(f.read()				)

          UpperCAmelCase          =       {'file_name': '000000039769.png', 'image_id': 3_9_7_6_9, 'segments_info': target}

          UpperCAmelCase          =       pathlib.Path('./tests/fixtures/tests_samples/COCO/coco_panoptic'				)

          # encode them
          UpperCAmelCase          =       DetaImageProcessor(format='coco_panoptic'				)
          UpperCAmelCase          =       image_processing(images=lowercase_ ,							annotations=lowercase_ ,							masks_path=lowercase_ ,							return_tensors='pt'				)

          # verify pixel values
          UpperCAmelCase          =       torch.Size([1, 3, 8_0_0, 1_0_6_6]				)
          self.assertEqual(encoding['pixel_values'].shape ,							lowercase_				)

          UpperCAmelCase          =       torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]				)
          self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3] ,							lowercase_ ,							atol=1E-4				)				)

          # verify area
          UpperCAmelCase          =       torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['area'] ,							lowercase_				)				)
          # verify boxes
          UpperCAmelCase          =       torch.Size([6, 4]				)
          self.assertEqual(encoding['labels'][0]['boxes'].shape ,							lowercase_				)
          UpperCAmelCase          =       torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0] ,							lowercase_ ,							atol=1E-3				)				)
          # verify image_id
          UpperCAmelCase          =       torch.tensor([3_9_7_6_9]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['image_id'] ,							lowercase_				)				)
          # verify is_crowd
          UpperCAmelCase          =       torch.tensor([0, 0, 0, 0, 0, 0]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd'] ,							lowercase_				)				)
          # verify class_labels
          UpperCAmelCase          =       torch.tensor([1_7, 1_7, 6_3, 7_5, 7_5, 9_3]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels'] ,							lowercase_				)				)
          # verify masks
          UpperCAmelCase          =       8_2_2_8_7_3
          self.assertEqual(encoding['labels'][0]['masks'].sum().item() ,							lowercase_				)
          # verify orig_size
          UpperCAmelCase          =       torch.tensor([4_8_0, 6_4_0]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size'] ,							lowercase_				)				)
          # verify size
          UpperCAmelCase          =       torch.tensor([8_0_0, 1_0_6_6]				)
          self.assertTrue(torch.allclose(encoding['labels'][0]['size'] ,							lowercase_				)				)



