


"""simple docstring"""



import datasets

from .evaluate import evaluate


UpperCAmelCase      		=			'''\
@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}
}
'''

UpperCAmelCase      		=			'''
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.
'''

UpperCAmelCase      		=			'''
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 					__magic_name__		(			datasets.Metric     ):






       def  __snake_case						(   self  :    str				):

             '''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  __snake_case						(   self  :    Any  ,     snake_case__  :    Dict  ,     snake_case__  :    Optional[Any]				):

             '''simple docstring'''






             lowercase		:Optional[Any]       							=				{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		:Optional[Any]       							=				evaluate(dataset=snake_case__  ,     predictions=snake_case__				)
             return score





"""simple docstring"""



import gc
import inspect
import unittest

import torch
from parameterized import parameterized

from diffusers import PriorTransformer
from diffusers.utils import floats_tensor, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin


enable_full_determinism()
class 					__magic_name__		(			__UpperCAmelCase			,						unittest.TestCase     ):
       __A			:      Tuple        =   PriorTransformer
       __A			:      Any        =   "hidden_states"






       @property
       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              lowercase		:Union[str, Any]       							=				4
              lowercase		:List[Any]       							=				8
              lowercase		:Any       							=				7

              lowercase		:Optional[Any]       							=				floats_tensor((batch_size, embedding_dim)				).to(snake_case__				)

              lowercase		:List[Any]       							=				floats_tensor((batch_size, embedding_dim)				).to(snake_case__				)
              lowercase		:Union[str, Any]       							=				floats_tensor((batch_size, num_embeddings, embedding_dim)				).to(snake_case__				)

              return {
                  "hidden_states": hidden_states,
                  "timestep": 2,
                  "proj_embedding": proj_embedding,
                  "encoder_hidden_states": encoder_hidden_states,
              }






       def  __snake_case						(   self  :    Dict  ,     snake_case__  :    Optional[Any]=0				):

              '''simple docstring'''






              torch.manual_seed(snake_case__				)
              lowercase		:Union[str, Any]       							=				4
              lowercase		:Optional[int]       							=				8
              lowercase		:str       							=				7

              lowercase		:Dict       							=				torch.randn((batch_size, embedding_dim)				).to(snake_case__				)

              lowercase		:Union[str, Any]       							=				torch.randn((batch_size, embedding_dim)				).to(snake_case__				)
              lowercase		:Tuple       							=				torch.randn((batch_size, num_embeddings, embedding_dim)				).to(snake_case__				)

              return {
                  "hidden_states": hidden_states,
                  "timestep": 2,
                  "proj_embedding": proj_embedding,
                  "encoder_hidden_states": encoder_hidden_states,
              }






       @property
       def  __snake_case						(   self  :    Union[str, Any]				):

              '''simple docstring'''






              return (4, 8)






       @property
       def  __snake_case						(   self  :    Dict				):

              '''simple docstring'''






              return (4, 8)






       def  __snake_case						(   self  :    Optional[Any]				):

              '''simple docstring'''






              lowercase		:Union[str, Any]       							=				{
                  '''num_attention_heads''': 2,
                  '''attention_head_dim''': 4,
                  '''num_layers''': 2,
                  '''embedding_dim''': 8,
                  '''num_embeddings''': 7,
                  '''additional_embeddings''': 4,
              }
              lowercase		:List[str]       							=				self.dummy_input
              return init_dict, inputs_dict






       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              lowercase							,  lowercase		:Optional[int]       							=				PriorTransformer.from_pretrained(
                  '''hf-internal-testing/prior-dummy'''  ,     output_loading_info=snake_case__				)
              self.assertIsNotNone(snake_case__				)
              self.assertEqual(len(loading_info['''missing_keys''']				)  ,     0				)

              model.to(snake_case__				)
              lowercase		:List[Any]       							=				model(**self.dummy_input				)[0]

              assert hidden_states is not None, "Make sure output is not None"






       def  __snake_case						(   self  :    Union[str, Any]				):

              '''simple docstring'''






              lowercase							,  lowercase		:List[Any]       							=				self.prepare_init_args_and_inputs_for_common()

              lowercase		:str       							=				self.model_class(**snake_case__				)
              lowercase		:Optional[Any]       							=				inspect.signature(model.forward				)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              lowercase		:List[Any]       							=				[*signature.parameters.keys()]

              lowercase		:Optional[Any]       							=				['''hidden_states''', '''timestep''']
              self.assertListEqual(arg_names[:2]  ,     snake_case__				)







       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Optional[int]       							=				PriorTransformer.from_pretrained('''hf-internal-testing/prior-dummy'''				)
              lowercase		:List[Any]       							=				model.to(snake_case__				)

              if hasattr(snake_case__  ,     '''set_default_attn_processor'''				):
                     model.set_default_attn_processor()

              lowercase		:List[str]       							=				self.get_dummy_seed_input()

              with torch.no_grad():
                     lowercase		:List[Any]       							=				model(**snake_case__				)[0]

              lowercase		:Dict       							=				output[0, :5].flatten().cpu()
              print(snake_case__				)

              # Since the VAE Gaussian prior's generator is seeded on the appropriate device,
              # the expected output slices are not the same for CPU and GPU.
              lowercase		:str       							=				torch.tensor([-1.34_36, -0.28_70, 0.75_38, 0.43_68, -0.02_39]				)
              self.assertTrue(torch_all_close(snake_case__  ,     snake_case__  ,     rtol=1e-2				)				)







@slow
class 					__magic_name__		(			unittest.TestCase     ):






       def  __snake_case						(   self  :    Tuple  ,     snake_case__  :    int=1  ,     snake_case__  :    int=7_6_8  ,     snake_case__  :    Optional[Any]=7_7  ,     snake_case__  :    Union[str, Any]=0				):

              '''simple docstring'''






              torch.manual_seed(snake_case__				)
              lowercase		:Any       							=				batch_size
              lowercase		:Dict       							=				embedding_dim
              lowercase		:int       							=				num_embeddings

              lowercase		:int       							=				torch.randn((batch_size, embedding_dim)				).to(snake_case__				)

              lowercase		:List[str]       							=				torch.randn((batch_size, embedding_dim)				).to(snake_case__				)
              lowercase		:Optional[Any]       							=				torch.randn((batch_size, num_embeddings, embedding_dim)				).to(snake_case__				)

              return {
                  "hidden_states": hidden_states,
                  "timestep": 2,
                  "proj_embedding": proj_embedding,
                  "encoder_hidden_states": encoder_hidden_states,
              }






       def  __snake_case						(   self  :    Dict				):

              '''simple docstring'''






              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()







       @parameterized.expand(
           [
               # fmt: off
               [1_3, [-0.58_61,  0.12_83, -0.09_31,  0.08_82,  0.44_76,  0.13_29, -0.04_98,  0.06_40]],
               [3_7, [-0.49_13,  0.01_10, -0.04_83,  0.05_41,  0.49_54, -0.01_70,  0.03_54,  0.16_51]],
               # fmt: on
           ]				)
       def  __snake_case						(   self  :    Dict  ,     snake_case__  :    Dict  ,     snake_case__  :    Union[str, Any]				):

              '''simple docstring'''






              lowercase		:str       							=				PriorTransformer.from_pretrained('''kandinsky-community/kandinsky-2-1-prior'''  ,     subfolder='''prior'''				)
              model.to(snake_case__				)
              lowercase		:Union[str, Any]       							=				self.get_dummy_seed_input(seed=snake_case__				)

              with torch.no_grad():
                     lowercase		:int       							=				model(**snake_case__				)[0]

              assert list(sample.shape				) == [1, 7_6_8]

              lowercase		:List[Any]       							=				sample[0, :8].flatten().cpu()
              print(snake_case__				)
              lowercase		:Union[str, Any]       							=				torch.tensor(snake_case__				)

              assert torch_all_close(snake_case__  ,     snake_case__  ,     atol=1e-3				)

