
import datasets

from .evaluate import evaluate


_lowercase			:  List[Any]   							=	'''\
@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}
}
'''

_lowercase			:  Optional[Any]   							=	'''
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.
'''

_lowercase			:  Any   							=	'''
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 			lowerCAmelCase__       (  datasets.Metric					):






					def      _snake_case   (       self		):


											"""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    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					Tuple													=	{prediction['id']: prediction['prediction_text'] for prediction in predictions}
											lowercase_     :					Union[str, Any]													=	[
											    {
											        'paragraphs': [
											            {
											                'qas': [
											                    {
											                        'answers': [{'text': answer_text} for answer_text in ref['answers']['text']],
											                        'id': ref['id'],
											                    }
											                    for ref in references
											                ]
											            }
											        ]
											    }
											]
											lowercase_     :					Dict													=	evaluate(dataset=__a    ,							predictions=__a		)
											return score





'''simple docstring'''







import torch

from diffusers import DDPMScheduler

from .test_schedulers import SchedulerCommonTest






class 			lowerCAmelCase__       (  lowerCamelCase_					):
					lowerCAmelCase_					       =					(DDPMScheduler,)






					def      _snake_case   (       self    ,							**__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					Optional[Any]													=	{
											    '''num_train_timesteps''': 10_00,
											    '''beta_start''': 0.0_001,
											    '''beta_end''': 0.02,
											    '''beta_schedule''': '''linear''',
											    '''variance_type''': '''fixed_small''',
											    '''clip_sample''': True,
											}

											config.update(**__SCREAMING_SNAKE_CASE		)
											return config






					def      _snake_case   (       self		):


											"""simple docstring"""





											for timesteps in [1, 5, 1_00, 10_00]:
																	self.check_over_configs(num_train_timesteps=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											for beta_start, beta_end in zip([0.0_001, 0.001, 0.01, 0.1]    ,							[0.002, 0.02, 0.2, 2]		):
																	self.check_over_configs(beta_start=__SCREAMING_SNAKE_CASE    ,							beta_end=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											for schedule in ["linear", "squaredcos_cap_v2"]:
																	self.check_over_configs(beta_schedule=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											for variance in ["fixed_small", "fixed_large", "other"]:
																	self.check_over_configs(variance_type=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											for clip_sample in [True, False]:
																	self.check_over_configs(clip_sample=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											self.check_over_configs(thresholding=__SCREAMING_SNAKE_CASE		)
											for threshold in [0.5, 1.0, 2.0]:
																	for prediction_type in ["epsilon", "sample", "v_prediction"]:
																							self.check_over_configs(
																							    thresholding=__SCREAMING_SNAKE_CASE    ,							prediction_type=__SCREAMING_SNAKE_CASE    ,							sample_max_value=__SCREAMING_SNAKE_CASE    ,							)






					def      _snake_case   (       self		):


											"""simple docstring"""





											for prediction_type in ["epsilon", "sample", "v_prediction"]:
																	self.check_over_configs(prediction_type=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											for t in [0, 5_00, 9_99]:
																	self.check_over_forward(time_step=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[str]													=	self.scheduler_classes[0]
											lowercase_     :					int													=	self.get_scheduler_config()
											lowercase_     :					str													=	scheduler_class(**__SCREAMING_SNAKE_CASE		)

											assert torch.sum(torch.abs(scheduler._get_variance(0		) - 0.0		)		) < 1E-5
											assert torch.sum(torch.abs(scheduler._get_variance(4_87		) - 0.00_979		)		) < 1E-5
											assert torch.sum(torch.abs(scheduler._get_variance(9_99		) - 0.02		)		) < 1E-5






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Union[str, Any]													=	self.scheduler_classes[0]
											lowercase_     :					Any													=	self.get_scheduler_config()
											lowercase_     :					Optional[int]													=	scheduler_class(**__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Any													=	len(__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[int]													=	self.dummy_model()
											lowercase_     :					Any													=	self.dummy_sample_deter
											lowercase_     :					List[str]													=	torch.manual_seed(0		)

											for t in reversed(range(__SCREAMING_SNAKE_CASE		)		):
																	# 1. predict noise residual
																	lowercase_     :					Optional[int]													=	model(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)

																	# 2. predict previous mean of sample x_t-1
																	lowercase_     :					Union[str, Any]													=	scheduler.step(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							generator=__SCREAMING_SNAKE_CASE		).prev_sample

																	# if t > 0:
																	#     noise = self.dummy_sample_deter
																	#     variance = scheduler.get_variance(t) ** (0.5) * noise
																	#
																	# sample = pred_prev_sample + variance
																	lowercase_     :					List[str]													=	pred_prev_sample

											lowercase_     :					str													=	torch.sum(torch.abs(__SCREAMING_SNAKE_CASE		)		)
											lowercase_     :					Tuple													=	torch.mean(torch.abs(__SCREAMING_SNAKE_CASE		)		)

											assert abs(result_sum.item() - 258.9_606		) < 1E-2
											assert abs(result_mean.item() - 0.3_372		) < 1E-3






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Optional[Any]													=	self.scheduler_classes[0]
											lowercase_     :					Tuple													=	self.get_scheduler_config(prediction_type='''v_prediction'''		)
											lowercase_     :					Any													=	scheduler_class(**__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[int]													=	len(__SCREAMING_SNAKE_CASE		)

											lowercase_     :					List[str]													=	self.dummy_model()
											lowercase_     :					int													=	self.dummy_sample_deter
											lowercase_     :					str													=	torch.manual_seed(0		)

											for t in reversed(range(__SCREAMING_SNAKE_CASE		)		):
																	# 1. predict noise residual
																	lowercase_     :					Optional[Any]													=	model(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)

																	# 2. predict previous mean of sample x_t-1
																	lowercase_     :					Optional[Any]													=	scheduler.step(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							generator=__SCREAMING_SNAKE_CASE		).prev_sample

																	# if t > 0:
																	#     noise = self.dummy_sample_deter
																	#     variance = scheduler.get_variance(t) ** (0.5) * noise
																	#
																	# sample = pred_prev_sample + variance
																	lowercase_     :					int													=	pred_prev_sample

											lowercase_     :					str													=	torch.sum(torch.abs(__SCREAMING_SNAKE_CASE		)		)
											lowercase_     :					Tuple													=	torch.mean(torch.abs(__SCREAMING_SNAKE_CASE		)		)

											assert abs(result_sum.item() - 202.0_296		) < 1E-2
											assert abs(result_mean.item() - 0.2_631		) < 1E-3






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Optional[int]													=	self.scheduler_classes[0]
											lowercase_     :					int													=	self.get_scheduler_config()
											lowercase_     :					int													=	scheduler_class(**__SCREAMING_SNAKE_CASE		)

											lowercase_     :					int													=	[1_00, 87, 50, 1, 0]

											scheduler.set_timesteps(timesteps=__SCREAMING_SNAKE_CASE		)

											lowercase_     :					List[str]													=	scheduler.timesteps

											for i, timestep in enumerate(__SCREAMING_SNAKE_CASE		):
																	if i == len(__SCREAMING_SNAKE_CASE		) - 1:
																							lowercase_     :					str													=	-1
																	else:
																							lowercase_     :					Any													=	timesteps[i + 1]

																	lowercase_     :					Optional[Any]													=	scheduler.previous_timestep(__SCREAMING_SNAKE_CASE		)
																	lowercase_     :					int													=	prev_t.item()

																	self.assertEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Tuple													=	self.scheduler_classes[0]
											lowercase_     :					List[Any]													=	self.get_scheduler_config()
											lowercase_     :					str													=	scheduler_class(**__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[int]													=	[1_00, 87, 50, 51, 0]

											with self.assertRaises(__SCREAMING_SNAKE_CASE    ,							msg='''`custom_timesteps` must be in descending order.'''		):
																	scheduler.set_timesteps(timesteps=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Optional[Any]													=	self.scheduler_classes[0]
											lowercase_     :					str													=	self.get_scheduler_config()
											lowercase_     :					Tuple													=	scheduler_class(**__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Tuple													=	[1_00, 87, 50, 1, 0]
											lowercase_     :					List[str]													=	len(__SCREAMING_SNAKE_CASE		)

											with self.assertRaises(__SCREAMING_SNAKE_CASE    ,							msg='''Can only pass one of `num_inference_steps` or `custom_timesteps`.'''		):
																	scheduler.set_timesteps(num_inference_steps=__SCREAMING_SNAKE_CASE    ,							timesteps=__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[Any]													=	self.scheduler_classes[0]
											lowercase_     :					Optional[int]													=	self.get_scheduler_config()
											lowercase_     :					Any													=	scheduler_class(**__SCREAMING_SNAKE_CASE		)

											lowercase_     :					str													=	[scheduler.config.num_train_timesteps]

											with self.assertRaises(
											    __SCREAMING_SNAKE_CASE    ,							msg='''`timesteps` must start before `self.config.train_timesteps`: {scheduler.config.num_train_timesteps}}'''    ,							):
																	scheduler.set_timesteps(timesteps=__SCREAMING_SNAKE_CASE		)



