






'''simple docstring'''
import datasets

from .evaluate import evaluate


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

UpperCamelCase__ =			'\nThis metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n'

UpperCamelCase__ =			'\nComputes SQuAD scores (F1 and EM).\nArgs:\n    predictions: List of question-answers dictionaries with the following key-values:\n        - \'id\': id of the question-answer pair as given in the references (see below)\n        - \'prediction_text\': the text of the answer\n    references: List of question-answers dictionaries with the following key-values:\n        - \'id\': id of the question-answer pair (see above),\n        - \'answers\': a Dict in the SQuAD dataset format\n            {\n                \'text\': list of possible texts for the answer, as a list of strings\n                \'answer_start\': list of start positions for the answer, as a list of ints\n            }\n            Note that answer_start values are not taken into account to compute the metric.\nReturns:\n    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)\n    \'f1\': The F-score of predicted tokens versus the gold answer\nExamples:\n\n    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]\n    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]\n    >>> squad_metric = datasets.load_metric("squad")\n    >>> results = squad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'exact_match\': 100.0, \'f1\': 100.0}\n'


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




    def 				lowerCAmelCase__				(			self  :       int			):






       '''simple docstring'''






       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 				lowerCAmelCase__				(			self  :       Optional[int]  ,     a  :       Any  ,     a  :       Union[str, Any]			):






       '''simple docstring'''






       lowercase_	:    List[str]           =     {prediction["id"]: prediction["prediction_text"] for prediction in predictions}
       lowercase_	:    List[str]           =     [
           {
               "paragraphs": [
                   {
                       "qas": [
                           {
                               "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
                               "id": ref["id"],
                           }
                           for ref in references
                       ]
                   }
               ]
           }
       ]
       lowercase_	:    List[str]           =     evaluate(dataset=a  ,     predictions=a			)
       return score







'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   def update_area_of_max_square(_UpperCamelCase						,		_UpperCamelCase							) -> int:
      # BASE CASE
      if row >= rows or col >= cols:
         return 0

      lowercase_	:    List[str]           =     update_area_of_max_square(_UpperCamelCase						,		col + 1							)
      lowercase_	:    List[Any]           =     update_area_of_max_square(row + 1						,		col + 1							)
      lowercase_	:    Tuple           =     update_area_of_max_square(row + 1						,		_UpperCamelCase							)

      if mat[row][col]:
         lowercase_	:    Optional[int]           =     1 + min([right, diagonal, down]							)
         lowercase_	:    Any           =     max(largest_square_area[0]						,		_UpperCamelCase							)
         return sub_problem_sol
      else:
         return 0

   lowercase_	:    int           =     [0]
   update_area_of_max_square(0						,		0							)
   return largest_square_area[0]




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   def update_area_of_max_square_using_dp_array(
       _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							) -> int:
      if row >= rows or col >= cols:
         return 0
      if dp_array[row][col] != -1:
         return dp_array[row][col]

      lowercase_	:    Dict           =     update_area_of_max_square_using_dp_array(_UpperCamelCase						,		col + 1						,		_UpperCamelCase							)
      lowercase_	:    str           =     update_area_of_max_square_using_dp_array(row + 1						,		col + 1						,		_UpperCamelCase							)
      lowercase_	:    Optional[Any]           =     update_area_of_max_square_using_dp_array(row + 1						,		_UpperCamelCase						,		_UpperCamelCase							)

      if mat[row][col]:
         lowercase_	:    Tuple           =     1 + min([right, diagonal, down]							)
         lowercase_	:    int           =     max(largest_square_area[0]						,		_UpperCamelCase							)
         lowercase_	:    Dict           =     sub_problem_sol
         return sub_problem_sol
      else:
         return 0

   lowercase_	:    Any           =     [0]
   lowercase_	:    Optional[int]           =     [[-1] * cols for _ in range(_UpperCamelCase							)]
   update_area_of_max_square_using_dp_array(0						,		0						,		_UpperCamelCase							)

   return largest_square_area[0]




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    str           =     [[0] * (cols + 1) for _ in range(rows + 1							)]
   lowercase_	:    List[Any]           =     0
   for row in range(rows - 1						,		-1						,		-1							):
      for col in range(cols - 1						,		-1						,		-1							):
         lowercase_	:    Tuple           =     dp_array[row][col + 1]
         lowercase_	:    List[str]           =     dp_array[row + 1][col + 1]
         lowercase_	:    List[Any]           =     dp_array[row + 1][col]

         if mat[row][col] == 1:
            lowercase_	:    Any           =     1 + min(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
            lowercase_	:    Any           =     max(dp_array[row][col]						,		_UpperCamelCase							)
         else:
            lowercase_	:    int           =     0

   return largest_square_area




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    Optional[int]           =     [0] * (cols + 1)
   lowercase_	:    Union[str, Any]           =     [0] * (cols + 1)
   lowercase_	:    int           =     0
   for row in range(rows - 1						,		-1						,		-1							):
      for col in range(cols - 1						,		-1						,		-1							):
         lowercase_	:    Dict           =     current_row[col + 1]
         lowercase_	:    List[Any]           =     next_row[col + 1]
         lowercase_	:    Tuple           =     next_row[col]

         if mat[row][col] == 1:
            lowercase_	:    Dict           =     1 + min(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
            lowercase_	:    int           =     max(current_row[col]						,		_UpperCamelCase							)
         else:
            lowercase_	:    Tuple           =     0
      lowercase_	:    Optional[Any]           =     current_row

   return largest_square_area


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(largest_square_area_in_matrix_bottom_up(2, 2, [[1, 1], [1, 1]]))




