
import datasets

from .evaluate import evaluate


lowercase_ 				=			"""\
@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_ 				=			"""
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_ 				=			"""
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       ):






     """simple docstring"""







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







       """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  UpperCAmelCase__							(				self							:							List[str]     ,						_A							:							Tuple     ,						_A							:							Optional[int] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Tuple					=		{prediction['''id''']: prediction['''prediction_text'''] for prediction in predictions}
       __SCREAMING_SNAKE_CASE      :	int					=		[
           {
               '''paragraphs''': [
                   {
                       '''qas''': [
                           {
                               '''answers''': [{'''text''': answer_text} for answer_text in ref['''answers''']['''text''']],
                               '''id''': ref['''id'''],
                           }
                           for ref in references
                       ]
                   }
               ]
           }
       ]
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		evaluate(dataset=_A     ,						predictions=_A )
       return score


import collections
import inspect
import unittest

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

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import (
		    FocalNetBackbone,
		    FocalNetForImageClassification,
		    FocalNetForMaskedImageModeling,
		    FocalNetModel,
		)
		from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor





class    __A:

					def __init__(						self       :  Tuple ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  Optional[Any]=1_3 ,       __UpperCamelCase       :  str=3_2 ,       __UpperCamelCase       :  List[Any]=2 ,       __UpperCamelCase       :  Tuple=3 ,       __UpperCamelCase       :  List[Any]=1_6 ,       __UpperCamelCase       :  int=[3_2, 6_4, 1_2_8] ,       __UpperCamelCase       :  Tuple=[1, 2, 1] ,       __UpperCamelCase       :  List[Any]=[2, 2, 4] ,       __UpperCamelCase       :  int=2 ,       __UpperCamelCase       :  Tuple=2.0 ,       __UpperCamelCase       :  List[str]=True ,       __UpperCamelCase       :  List[Any]=0.0 ,       __UpperCamelCase       :  List[Any]=0.0 ,       __UpperCamelCase       :  Tuple=0.1 ,       __UpperCamelCase       :  Any="gelu" ,       __UpperCamelCase       :  int=False ,       __UpperCamelCase       :  List[Any]=True ,       __UpperCamelCase       :  Tuple=0.02 ,       __UpperCamelCase       :  Union[str, Any]=1E-5 ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  List[Any]=None ,       __UpperCamelCase       :  Optional[Any]=True ,       __UpperCamelCase       :  Optional[int]=1_0 ,       __UpperCamelCase       :  Union[str, Any]=8 ,       __UpperCamelCase       :  Optional[Any]=["stage1", "stage2"] ,       __UpperCamelCase       :  Tuple=[1, 2] ,       ):
												lowerCamelCase_					=       parent
												lowerCamelCase_					=       batch_size
												lowerCamelCase_					=       image_size
												lowerCamelCase_					=       patch_size
												lowerCamelCase_					=       num_channels
												lowerCamelCase_					=       embed_dim
												lowerCamelCase_					=       hidden_sizes
												lowerCamelCase_					=       depths
												lowerCamelCase_					=       num_heads
												lowerCamelCase_					=       window_size
												lowerCamelCase_					=       mlp_ratio
												lowerCamelCase_					=       qkv_bias
												lowerCamelCase_					=       hidden_dropout_prob
												lowerCamelCase_					=       attention_probs_dropout_prob
												lowerCamelCase_					=       drop_path_rate
												lowerCamelCase_					=       hidden_act
												lowerCamelCase_					=       use_absolute_embeddings
												lowerCamelCase_					=       patch_norm
												lowerCamelCase_					=       layer_norm_eps
												lowerCamelCase_					=       initializer_range
												lowerCamelCase_					=       is_training
												lowerCamelCase_					=       scope
												lowerCamelCase_					=       use_labels
												lowerCamelCase_					=       type_sequence_label_size
												lowerCamelCase_					=       encoder_stride
												lowerCamelCase_					=       out_features
												lowerCamelCase_					=       out_indices

					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_					=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

												lowerCamelCase_					=       None
												if self.use_labels:
																			lowerCamelCase_					=       ids_tensor([self.batch_size] ,       self.type_sequence_label_size )

												lowerCamelCase_					=       self.get_config()

												return config, pixel_values, labels

					def  lowercase__   (						self       :  Dict ):
												return FocalNetConfig(
												    image_size=self.image_size ,       patch_size=self.patch_size ,       num_channels=self.num_channels ,       embed_dim=self.embed_dim ,       hidden_sizes=self.hidden_sizes ,       depths=self.depths ,       num_heads=self.num_heads ,       window_size=self.window_size ,       mlp_ratio=self.mlp_ratio ,       qkv_bias=self.qkv_bias ,       hidden_dropout_prob=self.hidden_dropout_prob ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob ,       drop_path_rate=self.drop_path_rate ,       hidden_act=self.hidden_act ,       use_absolute_embeddings=self.use_absolute_embeddings ,       path_norm=self.patch_norm ,       layer_norm_eps=self.layer_norm_eps ,       initializer_range=self.initializer_range ,       encoder_stride=self.encoder_stride ,       out_features=self.out_features ,       out_indices=self.out_indices ,       )

					def  lowercase__   (						self       :  List[str] ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  Union[str, Any] ):
												lowerCamelCase_					=       FocalNetModel(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase )

												lowerCamelCase_					=       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
												lowerCamelCase_					=       int(config.embed_dim * 2 ** (len(config.depths ) - 1) )

												self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, expected_seq_len, expected_dim) )

					def  lowercase__   (						self       :  Optional[Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  int ,       __UpperCamelCase       :  Union[str, Any] ):
												lowerCamelCase_					=       FocalNetBackbone(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase )

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps ) ,       len(config.out_features ) )
												self.parent.assertListEqual(list(result.feature_maps[0].shape ) ,       [self.batch_size, self.image_size, 8, 8] )

												# verify channels
												self.parent.assertEqual(len(model.channels ) ,       len(config.out_features ) )
												self.parent.assertListEqual(model.channels ,       config.hidden_sizes[:-1] )

												# verify backbone works with out_features=None
												lowerCamelCase_					=       None
												lowerCamelCase_					=       FocalNetBackbone(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase )

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps ) ,       1 )
												self.parent.assertListEqual(list(result.feature_maps[0].shape ) ,       [self.batch_size, self.image_size * 2, 4, 4] )

												# verify channels
												self.parent.assertEqual(len(model.channels ) ,       1 )
												self.parent.assertListEqual(model.channels ,       [config.hidden_sizes[-1]] )

					def  lowercase__   (						self       :  Optional[Any] ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Any ):
												lowerCamelCase_					=       FocalNetForMaskedImageModeling(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(
												    result.reconstruction.shape ,       (self.batch_size, self.num_channels, self.image_size, self.image_size) )

												# test greyscale images
												lowerCamelCase_					=       1
												lowerCamelCase_					=       FocalNetForMaskedImageModeling(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()

												lowerCamelCase_					=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.reconstruction.shape ,       (self.batch_size, 1, self.image_size, self.image_size) )

					def  lowercase__   (						self       :  str ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Union[str, Any] ):
												lowerCamelCase_					=       self.type_sequence_label_size
												lowerCamelCase_					=       FocalNetForImageClassification(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase ,       labels=__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size) )

												# test greyscale images
												lowerCamelCase_					=       1
												lowerCamelCase_					=       FocalNetForImageClassification(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()

												lowerCamelCase_					=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size) )



					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_					=       self.prepare_config_and_inputs()

												lowerCamelCase_	, lowerCamelCase_	, lowerCamelCase_					=       config_and_inputs
												lowerCamelCase_					=       {"""pixel_values""": pixel_values}
												return config, inputs_dict





@require_torch
class    __A(					UpperCAmelCase  ,		UpperCAmelCase  ,		unittest.TestCase							):
					SCREAMING_SNAKE_CASE           =     (
					    (
					        FocalNetModel,
					        FocalNetForImageClassification,
					        FocalNetForMaskedImageModeling,
					        FocalNetBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE           =     (
					    {'''feature-extraction''': FocalNetModel, '''image-classification''': FocalNetForImageClassification}
					    if is_torch_available()
					    else {}
					)
					SCREAMING_SNAKE_CASE           =     False

					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False

					def  lowercase__   (						self       :  str ):
												lowerCamelCase_					=       FocalNetModelTester(self )
												lowerCamelCase_					=       ConfigTester(self ,       config_class=__UpperCamelCase ,       embed_dim=3_7 ,       has_text_modality=__UpperCamelCase )

					def  lowercase__   (						self       :  Optional[Any] ):
												self.create_and_test_config_common_properties()
												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()

					def  lowercase__   (						self       :  Tuple ):
												return

					def  lowercase__   (						self       :  Optional[int] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase )

					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*__UpperCamelCase )

					def  lowercase__   (						self       :  List[Any] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase )

					def  lowercase__   (						self       :  List[Any] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase )

					@unittest.skip(reason="""FocalNet does not use inputs_embeds""" )
					def  lowercase__   (						self       :  str ):
												pass

					@unittest.skip(reason="""FocalNet does not use feedforward chunking""" )
					def  lowercase__   (						self       :  List[str] ):
												pass

					def  lowercase__   (						self       :  Optional[int] ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes[:-1]:
																			lowerCamelCase_					=       model_class(__UpperCamelCase )
																			self.assertIsInstance(model.get_input_embeddings() ,       (nn.Module) )
																			lowerCamelCase_					=       model.get_output_embeddings()
																			self.assertTrue(x is None or isinstance(__UpperCamelCase ,       nn.Linear ) )

					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes[:-1]:
																			lowerCamelCase_					=       model_class(__UpperCamelCase )
																			lowerCamelCase_					=       inspect.signature(model.forward )
																			# signature.parameters is an OrderedDict => so arg_names order is deterministic
																			lowerCamelCase_					=       [*signature.parameters.keys()]

																			lowerCamelCase_					=       ["""pixel_values"""]
																			self.assertListEqual(arg_names[:1] ,       __UpperCamelCase )

					def  lowercase__   (						self       :  Dict ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[Any] ):
												lowerCamelCase_					=       model_class(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()

												with torch.no_grad():
																			lowerCamelCase_					=       model(**self._prepare_for_class(__UpperCamelCase ,       __UpperCamelCase ) )

												lowerCamelCase_					=       outputs.hidden_states

												lowerCamelCase_					=       getattr(
												    self.model_tester ,       """expected_num_hidden_layers""" ,       len(self.model_tester.depths ) + 1 )
												self.assertEqual(len(__UpperCamelCase ) ,       __UpperCamelCase )

												# FocalNet has a different seq_length
												lowerCamelCase_					=       (
												    config.patch_size
												    if isinstance(config.patch_size ,       collections.abc.Iterable )
												    else (config.patch_size, config.patch_size)
												)

												lowerCamelCase_					=       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

												self.assertListEqual(
												    list(hidden_states[0].shape[-2:] ) ,       [num_patches, self.model_tester.embed_dim] ,       )

												lowerCamelCase_					=       outputs.reshaped_hidden_states
												self.assertEqual(len(__UpperCamelCase ) ,       __UpperCamelCase )

												lowerCamelCase_	, lowerCamelCase_	, lowerCamelCase_	, lowerCamelCase_					=       reshaped_hidden_states[0].shape
												lowerCamelCase_					=       (
												    reshaped_hidden_states[0].view(__UpperCamelCase ,       __UpperCamelCase ,       height * width ).permute(0 ,       2 ,       1 )
												)
												self.assertListEqual(
												    list(reshaped_hidden_states.shape[-2:] ) ,       [num_patches, self.model_tester.embed_dim] ,       )

					def  lowercase__   (						self       :  int ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

												lowerCamelCase_					=       (
												    self.model_tester.image_size
												    if isinstance(self.model_tester.image_size ,       collections.abc.Iterable )
												    else (self.model_tester.image_size, self.model_tester.image_size)
												)

												for model_class in self.all_model_classes[:-1]:
																			lowerCamelCase_					=       True
																			self.check_hidden_states_output(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase )

																			# check that output_hidden_states also work using config
																			del inputs_dict["output_hidden_states"]
																			lowerCamelCase_					=       True

																			self.check_hidden_states_output(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase )

					def  lowercase__   (						self       :  List[str] ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()
												lowerCamelCase_					=       3

												lowerCamelCase_					=       (
												    self.model_tester.image_size
												    if isinstance(self.model_tester.image_size ,       collections.abc.Iterable )
												    else (self.model_tester.image_size, self.model_tester.image_size)
												)
												lowerCamelCase_					=       (
												    config.patch_size
												    if isinstance(config.patch_size ,       collections.abc.Iterable )
												    else (config.patch_size, config.patch_size)
												)

												lowerCamelCase_					=       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
												lowerCamelCase_					=       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

												for model_class in self.all_model_classes[:-1]:
																			lowerCamelCase_					=       True
																			self.check_hidden_states_output(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase ,       (padded_height, padded_width) )

																			# check that output_hidden_states also work using config
																			del inputs_dict["output_hidden_states"]
																			lowerCamelCase_					=       True
																			self.check_hidden_states_output(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase ,       (padded_height, padded_width) )

					@slow
					def  lowercase__   (						self       :  Dict ):
												for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			lowerCamelCase_					=       FocalNetModel.from_pretrained(__UpperCamelCase )
																			self.assertIsNotNone(__UpperCamelCase )



					def  lowercase__   (						self       :  int ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

												lowerCamelCase_					=       _config_zero_init(__UpperCamelCase )
												for model_class in self.all_model_classes:
																			lowerCamelCase_					=       model_class(config=__UpperCamelCase )
																			for name, param in model.named_parameters():
																										if "embeddings" not in name and param.requires_grad:
																																	self.assertIn(
																																	    ((param.data.mean() * 1E9).round() / 1E9).item() ,       [0.0, 1.0] ,       msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' ,       )





@require_vision
@require_torch
class    __A(					unittest.TestCase							):

					@cached_property
					def  lowercase__   (						self       :  int ):
												# TODO update organization
												return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny""" ) if is_vision_available() else None



					@slow
					def  lowercase__   (						self       :  str ):
												lowerCamelCase_					=       FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny""" ).to(__UpperCamelCase )
												lowerCamelCase_					=       self.default_image_processor

												lowerCamelCase_					=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
												lowerCamelCase_					=       image_processor(images=__UpperCamelCase ,       return_tensors="""pt""" ).to(__UpperCamelCase )

												# forward pass
												with torch.no_grad():
																			lowerCamelCase_					=       model(**__UpperCamelCase )

												# verify the logits
												lowerCamelCase_					=       torch.Size((1, 1_0_0_0) )
												self.assertEqual(outputs.logits.shape ,       __UpperCamelCase )
												lowerCamelCase_					=       torch.tensor([0.2166, -0.4368, 0.2191] ).to(__UpperCamelCase )
												self.assertTrue(torch.allclose(outputs.logits[0, :3] ,       __UpperCamelCase ,       atol=1E-4 ) )
												self.assertTrue(outputs.logits.argmax(dim=-1 ).item() ,       2_8_1 )





@require_torch
class    __A(					UpperCAmelCase  ,		unittest.TestCase							):
					SCREAMING_SNAKE_CASE           =     (FocalNetBackbone,) if is_torch_available() else ()
					SCREAMING_SNAKE_CASE           =     FocalNetConfig

					SCREAMING_SNAKE_CASE           =     False

					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       FocalNetModelTester(self )





