




import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
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_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
	    MODEL_MAPPING,
	    EfficientFormerForImageClassification,
	    EfficientFormerForImageClassificationWithTeacher,
	    EfficientFormerModel,
	)
	from transformers.models.efficientformer.modeling_efficientformer import (
	    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
	)


if is_vision_available():
	from PIL import Image

	from transformers import EfficientFormerImageProcessor

class 	_lowerCamelCase  :

						"""simple docstring"""

						def __init__(       self   :	Optional[int]	,    snake_case   :	List[Any]	,    snake_case   :	int = 13	,    snake_case   :	int = 64	,    snake_case   :	int = 2	,    snake_case   :	int = 3	,    snake_case   :	int = 3	,    snake_case   :	bool = True	,    snake_case   :	bool = True	,    snake_case   :	int = 128	,    snake_case   :	Union[str, Any]=[16, 32, 64, 128]	,    snake_case   :	int = 7	,    snake_case   :	int = 4	,    snake_case   :	int = 37	,    snake_case   :	str = "gelu"	,    snake_case   :	float = 0.1	,    snake_case   :	float = 0.1	,    snake_case   :	int = 10	,    snake_case   :	float = 0.02	,    snake_case   :	int = 2	,    snake_case   :	int = 1	,    snake_case   :	int = 128	,    snake_case   :	List[int] = [2, 2, 2, 2]	,    snake_case   :	int = 2	,    snake_case   :	int = 2	,    ):
										__UpperCamelCase											=  parent
										__UpperCamelCase											=  batch_size
										__UpperCamelCase											=  image_size
										__UpperCamelCase											=  patch_size
										__UpperCamelCase											=  num_channels
										__UpperCamelCase											=  is_training
										__UpperCamelCase											=  use_labels
										__UpperCamelCase											=  hidden_size
										__UpperCamelCase											=  num_hidden_layers
										__UpperCamelCase											=  num_attention_heads
										__UpperCamelCase											=  intermediate_size
										__UpperCamelCase											=  hidden_act
										__UpperCamelCase											=  hidden_dropout_prob
										__UpperCamelCase											=  attention_probs_dropout_prob
										__UpperCamelCase											=  type_sequence_label_size
										__UpperCamelCase											=  initializer_range
										__UpperCamelCase											=  encoder_stride
										__UpperCamelCase											=  num_attention_outputs
										__UpperCamelCase											=  embed_dim
										__UpperCamelCase											=  embed_dim + 1
										__UpperCamelCase											=  resolution
										__UpperCamelCase											=  depths
										__UpperCamelCase											=  hidden_sizes
										__UpperCamelCase											=  dim
										__UpperCamelCase											=  mlp_expansion_ratio







						def  snake_case		(       self   :	Dict			):
										__UpperCamelCase											=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

										__UpperCamelCase											=  self.get_config()
										return config, pixel_values, labels







						def  snake_case		(       self   :	Any			):
										return EfficientFormerConfig(
										    image_size=self.image_size	,    patch_size=self.patch_size	,    num_channels=self.num_channels	,    hidden_size=self.hidden_size	,    num_hidden_layers=self.num_hidden_layers	,    num_attention_heads=self.num_attention_heads	,    intermediate_size=self.intermediate_size	,    hidden_act=self.hidden_act	,    hidden_dropout_prob=self.hidden_dropout_prob	,    attention_probs_dropout_prob=self.attention_probs_dropout_prob	,    is_decoder=__lowercase	,    initializer_range=self.initializer_range	,    encoder_stride=self.encoder_stride	,    resolution=self.resolution	,    depths=self.depths	,    hidden_sizes=self.hidden_sizes	,    dim=self.dim	,    mlp_expansion_ratio=self.mlp_expansion_ratio	,    )







						def  snake_case		(       self   :	Dict	,    snake_case   :	Union[str, Any]	,    snake_case   :	List[str]	,    snake_case   :	List[str]			):
										__UpperCamelCase											=  EfficientFormerModel(config=__lowercase			)
										model.to(__lowercase			)
										model.eval()
										__UpperCamelCase											=  model(__lowercase			)
										self.parent.assertEqual(result.last_hidden_state.shape	,    (self.batch_size, self.seq_length, self.hidden_size)			)







						def  snake_case		(       self   :	Optional[int]	,    snake_case   :	int	,    snake_case   :	int	,    snake_case   :	List[str]			):
										__UpperCamelCase											=  self.type_sequence_label_size
										__UpperCamelCase											=  EfficientFormerForImageClassification(__lowercase			)
										model.to(__lowercase			)
										model.eval()
										__UpperCamelCase											=  model(__lowercase	,    labels=__lowercase			)
										self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.type_sequence_label_size)			)

										# test greyscale images
										__UpperCamelCase											=  1
										__UpperCamelCase											=  EfficientFormerForImageClassification(__lowercase			)
										model.to(__lowercase			)
										model.eval()

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







						def  snake_case		(       self   :	List[str]			):
										__UpperCamelCase											=  self.prepare_config_and_inputs()
										(
										    (
										    __UpperCamelCase				
										)						, (
										    __UpperCamelCase				
										)						, (
										    __UpperCamelCase				
										)						, 				
										)											=  config_and_inputs
										__UpperCamelCase											=  {'''pixel_values''': pixel_values}
										return config, inputs_dict







@require_torch
class 	_lowerCamelCase  (     UpperCAmelCase__							,     UpperCAmelCase__							,     unittest.TestCase				):

						"""simple docstring"""

						lowerCAmelCase__     :	int      =   (
						    (
						        EfficientFormerModel,
						        EfficientFormerForImageClassificationWithTeacher,
						        EfficientFormerForImageClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase__     :	Tuple      =   (
						    {
						        "feature-extraction": EfficientFormerModel,
						        "image-classification": (
						            EfficientFormerForImageClassification,
						            EfficientFormerForImageClassificationWithTeacher,
						        ),
						    }
						    if is_torch_available()
						    else {}
						)
						lowerCAmelCase__     :	Dict      =   False

						lowerCAmelCase__     :	Tuple      =   False
						lowerCAmelCase__     :	Dict      =   False
						lowerCAmelCase__     :	Tuple      =   False







						def  snake_case		(       self   :	Dict			):
										__UpperCamelCase											=  EfficientFormerModelTester(self			)
										__UpperCamelCase											=  ConfigTester(
										    self	,    config_class=__lowercase	,    has_text_modality=__lowercase	,    hidden_size=37			)







						def  snake_case		(       self   :	int			):
										self.config_tester.run_common_tests()







						@unittest.skip(reason='''EfficientFormer does not use inputs_embeds'''			)
						def  snake_case		(       self   :	Tuple			):
										pass







						@unittest.skip(reason='''EfficientFormer does not support input and output embeddings'''			)
						def  snake_case		(       self   :	List[Any]			):
										pass







						def  snake_case		(       self   :	Dict			):
										__UpperCamelCase						, __UpperCamelCase											=  self.model_tester.prepare_config_and_inputs_for_common()

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

														__UpperCamelCase											=  ['''pixel_values''']
														self.assertListEqual(arg_names[:1]	,    __lowercase			)







						def  snake_case		(       self   :	List[str]			):






										def check_hidden_states_output(snake_case   :	Optional[Any]	,    snake_case   :	str	,    snake_case   :	Optional[int]			):
														__UpperCamelCase											=  model_class(__lowercase			)
														model.to(__lowercase			)
														model.eval()

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

														__UpperCamelCase											=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

														__UpperCamelCase											=  getattr(
														    self.model_tester	,    '''expected_num_hidden_layers'''	,    self.model_tester.num_hidden_layers + 1			)
														self.assertEqual(len(__lowercase			)	,    __lowercase			)

														if hasattr(self.model_tester	,    '''encoder_seq_length'''			):
																		__UpperCamelCase											=  self.model_tester.encoder_seq_length
																		if hasattr(self.model_tester	,    '''chunk_length'''			) and self.model_tester.chunk_length > 1:
																						__UpperCamelCase											=  seq_length * self.model_tester.chunk_length
														else:
																		__UpperCamelCase											=  self.model_tester.seq_length

														self.assertListEqual(
														    list(hidden_states[-1].shape[-2:]			)	,    [seq_length, self.model_tester.hidden_size]	,    )

														if config.is_encoder_decoder:
																		__UpperCamelCase											=  outputs.decoder_hidden_states

																		self.assertIsInstance(__lowercase	,    (list, tuple)			)
																		self.assertEqual(len(__lowercase			)	,    __lowercase			)
																		__UpperCamelCase											=  getattr(self.model_tester	,    '''seq_length'''	,    __lowercase			)
																		__UpperCamelCase											=  getattr(self.model_tester	,    '''decoder_seq_length'''	,    __lowercase			)

																		self.assertListEqual(
																		    list(hidden_states[-1].shape[-2:]			)	,    [decoder_seq_length, self.model_tester.hidden_size]	,    )

										__UpperCamelCase						, __UpperCamelCase											=  self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														__UpperCamelCase											=  True
														check_hidden_states_output(__lowercase	,    __lowercase	,    __lowercase			)

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

														check_hidden_states_output(__lowercase	,    __lowercase	,    __lowercase			)







						def  snake_case		(       self   :	List[str]	,    snake_case   :	List[str]	,    snake_case   :	Dict	,    snake_case   :	List[Any]=False			):
										__UpperCamelCase											=  super()._prepare_for_class(__lowercase	,    __lowercase	,    return_labels=__lowercase			)

										if return_labels:
														if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
																		del inputs_dict["labels"]

										return inputs_dict







						def  snake_case		(       self   :	str			):
										__UpperCamelCase											=  self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__lowercase			)







						@unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet'''			)
						def  snake_case		(       self   :	Dict			):
										__UpperCamelCase											=  self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*__lowercase			)







						def  snake_case		(       self   :	str			):
										__UpperCamelCase											=  self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*__lowercase			)







						def  snake_case		(       self   :	List[str]			):






										if not self.model_tester.is_training:
														return

										__UpperCamelCase						, __UpperCamelCase											=  self.model_tester.prepare_config_and_inputs_for_common()
										__UpperCamelCase											=  True

										for model_class in self.all_model_classes:
														# EfficientFormerForImageClassificationWithTeacher supports inference-only
														if (
														    model_class in get_values(__lowercase			)
														    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
														):
																		continue
														__UpperCamelCase											=  model_class(__lowercase			)
														model.to(__lowercase			)
														model.train()
														__UpperCamelCase											=  self._prepare_for_class(__lowercase	,    __lowercase	,    return_labels=__lowercase			)
														__UpperCamelCase											=  model(**__lowercase			).loss
														loss.backward()







						def  snake_case		(       self   :	List[Any]			):
										__UpperCamelCase						, __UpperCamelCase											=  self.model_tester.prepare_config_and_inputs_for_common()

										__UpperCamelCase											=  [
										    {'''title''': '''multi_label_classification''', '''num_labels''': 2, '''dtype''': torch.float},
										    {'''title''': '''single_label_classification''', '''num_labels''': 1, '''dtype''': torch.long},
										    {'''title''': '''regression''', '''num_labels''': 1, '''dtype''': torch.float},
										]

										for model_class in self.all_model_classes:
														if (
														    model_class
														    not in [
														        *get_values(__lowercase			),
														    ]
														    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
														):
																		continue

														for problem_type in problem_types:
																		with self.subTest(msg=F"Testing {model_class} with {problem_type['title']}"			):
																						__UpperCamelCase											=  problem_type['''title''']
																						__UpperCamelCase											=  problem_type['''num_labels''']

																						__UpperCamelCase											=  model_class(__lowercase			)
																						model.to(__lowercase			)
																						model.train()

																						__UpperCamelCase											=  self._prepare_for_class(__lowercase	,    __lowercase	,    return_labels=__lowercase			)

																						if problem_type["num_labels"] > 1:
																										__UpperCamelCase											=  inputs['''labels'''].unsqueeze(1			).repeat(1	,    problem_type['''num_labels''']			)

																						__UpperCamelCase											=  inputs['''labels'''].to(problem_type['''dtype''']			)

																						# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																						# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																						# they have the same size." which is a symptom something in wrong for the regression problem.
																						# See https://github.com/huggingface/transformers/issues/11780
																						with warnings.catch_warnings(record=__lowercase			) as warning_list:
																										__UpperCamelCase											=  model(**__lowercase			).loss
																						for w in warning_list:
																										if "Using a target size that is different to the input size" in str(w.message			):
																														raise ValueError(
																														    F"Something is going wrong in the regression problem: intercepted {w.message}"			)

																						loss.backward()







						@slow
						def  snake_case		(       self   :	Union[str, Any]			):






										for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														__UpperCamelCase											=  EfficientFormerModel.from_pretrained(__lowercase			)
														self.assertIsNotNone(__lowercase			)







						def  snake_case		(       self   :	Optional[Any]			):
										__UpperCamelCase						, __UpperCamelCase											=  self.model_tester.prepare_config_and_inputs_for_common()
										__UpperCamelCase											=  True

										__UpperCamelCase											=  getattr(self.model_tester	,    '''seq_length'''	,    __lowercase			)
										__UpperCamelCase											=  getattr(self.model_tester	,    '''encoder_seq_length'''	,    __lowercase			)
										__UpperCamelCase											=  getattr(self.model_tester	,    '''key_length'''	,    __lowercase			)
										__UpperCamelCase											=  getattr(self.model_tester	,    '''chunk_length'''	,    __lowercase			)

										if chunk_length is not None and hasattr(self.model_tester	,    '''num_hashes'''			):
														__UpperCamelCase											=  encoder_seq_length * self.model_tester.num_hashes

										for model_class in self.all_model_classes:
														__UpperCamelCase											=  True
														__UpperCamelCase											=  False
														__UpperCamelCase											=  True
														__UpperCamelCase											=  model_class(__lowercase			)
														model.to(__lowercase			)
														model.eval()
														with torch.no_grad():
																		__UpperCamelCase											=  model(**self._prepare_for_class(__lowercase	,    __lowercase			)			)
														__UpperCamelCase											=  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
														self.assertEqual(len(__lowercase			)	,    self.model_tester.num_attention_outputs			)

														# check that output_attentions also work using config
														del inputs_dict["output_attentions"]
														__UpperCamelCase											=  True
														__UpperCamelCase											=  model_class(__lowercase			)
														model.to(__lowercase			)
														model.eval()
														with torch.no_grad():
																		__UpperCamelCase											=  model(**self._prepare_for_class(__lowercase	,    __lowercase			)			)
														__UpperCamelCase											=  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
														self.assertEqual(len(__lowercase			)	,    self.model_tester.num_attention_outputs			)

														if chunk_length is not None:
																		self.assertListEqual(
																		    list(attentions[0].shape[-4:]			)	,    [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]	,    )
														else:
																		self.assertListEqual(
																		    list(attentions[0].shape[-3:]			)	,    [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]	,    )







def    __SCREAMING_SNAKE_CASE				(					)    ->		List[Any]:

				"""simple docstring"""


				__UpperCamelCase											=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
				return image


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

						"""simple docstring"""

						@cached_property
						def  snake_case		(       self   :	List[str]			):
										return (
										    EfficientFormerImageProcessor.from_pretrained('''snap-research/efficientformer-l1-300'''			)
										    if is_vision_available()
										    else None
										)







						@slow
						def  snake_case		(       self   :	Optional[int]			):
										__UpperCamelCase											=  EfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''			).to(
										    __lowercase			)

										__UpperCamelCase											=  self.default_image_processor
										__UpperCamelCase											=  prepare_img()
										__UpperCamelCase											=  image_processor(images=__lowercase	,    return_tensors='''pt'''			).to(__lowercase			)

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

										# verify the logits
										__UpperCamelCase											=  (1, 1000)
										self.assertEqual(outputs.logits.shape	,    __lowercase			)

										__UpperCamelCase											=  torch.tensor([-0.05_55, 0.48_25, -0.08_52]			).to(__lowercase			)
										self.assertTrue(torch.allclose(outputs.logits[0][:3]	,    __lowercase	,    atol=1E-4			)			)







						@slow
						def  snake_case		(       self   :	Optional[Any]			):
										__UpperCamelCase											=  EfficientFormerForImageClassificationWithTeacher.from_pretrained(
										    '''snap-research/efficientformer-l1-300'''			).to(__lowercase			)

										__UpperCamelCase											=  self.default_image_processor
										__UpperCamelCase											=  prepare_img()
										__UpperCamelCase											=  image_processor(images=__lowercase	,    return_tensors='''pt'''			).to(__lowercase			)

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

										# verify the logits
										__UpperCamelCase											=  (1, 1000)
										self.assertEqual(outputs.logits.shape	,    __lowercase			)

										__UpperCamelCase											=  torch.tensor([-0.13_12, 0.43_53, -1.04_99]			).to(__lowercase			)
										self.assertTrue(torch.allclose(outputs.logits[0][:3]	,    __lowercase	,    atol=1E-4			)			)












import argparse
import json
import re
import string
import sys
from collections import Counter




def    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		Dict:

    """simple docstring"""


    def remove_articles(lowercase_ ):
        return re.sub(r'''\b(a|an|the)\b'''   ,       ''' '''   ,       lowercase_ )

    def white_space_fix(lowercase_ ):
        return " ".join(text.split() )

    def remove_punc(lowercase_ ):
        __UpperCamelCase											=  set(string.punctuation )
        return "".join(ch for ch in text if ch not in exclude )

    def lower(lowercase_ ):
        return text.lower()

    return white_space_fix(remove_articles(remove_punc(lower(lowercase_ ) ) ) )




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_ )    ->		List[str]:

    """simple docstring"""


    __UpperCamelCase											=  normalize_answer(lowercase_ ).split()
    __UpperCamelCase											=  normalize_answer(lowercase_ ).split()
    __UpperCamelCase											=  Counter(lowercase_ ) & Counter(lowercase_ )
    __UpperCamelCase											=  sum(common.values() )
    if num_same == 0:
        return 0
    __UpperCamelCase											=  1.0 * num_same / len(lowercase_ )
    __UpperCamelCase											=  1.0 * num_same / len(lowercase_ )
    __UpperCamelCase											=  (2 * precision * recall) / (precision + recall)
    return fa




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_ )    ->		Any:

    """simple docstring"""


    return normalize_answer(lowercase_ ) == normalize_answer(lowercase_ )




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_   ,       lowercase_ )    ->		int:

    """simple docstring"""


    __UpperCamelCase											=  []
    for ground_truth in ground_truths:
        __UpperCamelCase											=  metric_fn(lowercase_   ,       lowercase_ )
        scores_for_ground_truths.append(lowercase_ )
    return max(lowercase_ )




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_ )    ->		Optional[int]:

    """simple docstring"""


    __UpperCamelCase											=  __UpperCamelCase											=  __UpperCamelCase											=  0
    __UpperCamelCase											=  []
    for passage in dataset:
        for qa in passage["qas"]:
            total += 1
            if qa["id"] not in predictions:
                __UpperCamelCase											=  F"Unanswered question {qa['id']} will receive score 0."
                print(lowercase_   ,       file=sys.stderr )
                continue

            __UpperCamelCase											=  [x['''text'''] for x in qa['''answers''']]
            __UpperCamelCase											=  predictions[qa['''id''']]

            __UpperCamelCase											=  metric_max_over_ground_truths(lowercase_   ,       lowercase_   ,       lowercase_ )
            if int(_exact_match ) == 1:
                correct_ids.append(qa['''id'''] )
            exact_match += _exact_match

            fa += metric_max_over_ground_truths(lowercase_   ,       lowercase_   ,       lowercase_ )

    __UpperCamelCase											=  exact_match / total
    __UpperCamelCase											=  fa / total

    return {"exact_match": exact_match, "f1": fa}, correct_ids


if __name__ == "__main__":
 a_										=       "1.0"
 a_										=       argparse.ArgumentParser("Official evaluation script for ReCoRD v1.0.")
 parser.add_argument("data_file", help="The dataset file in JSON format.")
 parser.add_argument("pred_file", help="The model prediction file in JSON format.")
 parser.add_argument("--output_correct_ids", action="store_true", help="Output the correctly answered query IDs.")
 a_										=       parser.parse_args()

 with open(args.data_file) as data_file:
  a_										=       json.load(data_file)
  if dataset_json["version"] != expected_version:
   print(
       f"""Evaluation expects v-{expected_version}, but got dataset with v-{dataset_json['version']}""",
       file=sys.stderr,
   )
  a_										=       dataset_json["data"]

 with open(args.pred_file) as pred_file:
  a_										=       json.load(pred_file)

 a_						,      a_										=       evaluate(dataset, predictions)

 if args.output_correct_ids:
  print(f"""Output {len(correct_ids)} correctly answered question IDs.""")
  with open("correct_ids.json", "w") as f:
   json.dump(correct_ids, f)






