





"""simple docstring"""


import functools
from contextlib import contextmanager

import bert_score
from packaging import version

import datasets





@contextmanager
def 							a__			(  )    ->  Optional[int]:

 '''simple docstring'''






 def filter_log(_UpperCAmelCase	):
  return False if "This IS expected if you are initializing" in record.msg else True

 snake_case__    							=				datasets.utils.logging.get_logger("transformers.modeling_utils"	)
 logger.addFilter(lowercase__	)
 try:
  yield
 finally:
  logger.removeFilter(lowercase__	)


a__					:     Optional[int]							=				'\\n@inproceedings{bert-score,\n  title={BERTScore: Evaluating Text Generation with BERT},\n  author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},\n  booktitle={International Conference on Learning Representations},\n  year={2020},\n  url={https://openreview.net/forum?id=SkeHuCVFDr}\n}\n'

a__					:     Optional[Any]							=				'\\nBERTScore leverages the pre-trained contextual embeddings from BERT and matches words in candidate and reference\nsentences by cosine similarity.\nIt has been shown to correlate with human judgment on sentence-level and system-level evaluation.\nMoreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language\ngeneration tasks.\n\nSee the project\'s README at https://github.com/Tiiiger/bert_score#readme for more information.\n'

a__					:     str							=				'\nBERTScore Metrics with the hashcode from a source against one or more references.\n\nArgs:\n    predictions (list of str): Prediction/candidate sentences.\n    references (list of str or list of list of str): Reference sentences.\n    lang (str): Language of the sentences; required (e.g. \'en\').\n    model_type (str): Bert specification, default using the suggested\n        model for the target language; has to specify at least one of\n        `model_type` or `lang`.\n    num_layers (int): The layer of representation to use,\n        default using the number of layers tuned on WMT16 correlation data.\n    verbose (bool): Turn on intermediate status update.\n    idf (bool or dict): Use idf weighting; can also be a precomputed idf_dict.\n    device (str): On which the contextual embedding model will be allocated on.\n        If this argument is None, the model lives on cuda:0 if cuda is available.\n    nthreads (int): Number of threads.\n    batch_size (int): Bert score processing batch size,\n        at least one of `model_type` or `lang`. `lang` needs to be\n        specified when `rescale_with_baseline` is True.\n    rescale_with_baseline (bool): Rescale bertscore with pre-computed baseline.\n    baseline_path (str): Customized baseline file.\n    use_fast_tokenizer (bool): `use_fast` parameter passed to HF tokenizer. New in version 0.3.10.\n\nReturns:\n    precision: Precision.\n    recall: Recall.\n    f1: F1 score.\n    hashcode: Hashcode of the library.\n\nExamples:\n\n    >>> predictions = ["hello there", "general kenobi"]\n    >>> references = ["hello there", "general kenobi"]\n    >>> bertscore = datasets.load_metric("bertscore")\n    >>> results = bertscore.compute(predictions=predictions, references=references, lang="en")\n    >>> print([round(v, 2) for v in results["f1"]])\n    [1.0, 1.0]\n'



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

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        return datasets.MetricInfo(
            description=_DESCRIPTION   ,					citation=_CITATION   ,					homepage="https://github.com/Tiiiger/bert_score"   ,					inputs_description=_KWARGS_DESCRIPTION   ,					features=datasets.Features(
                {
                    "predictions": datasets.Value("string"   ,					id="sequence"     ),
                    "references": datasets.Sequence(datasets.Value("string"   ,					id="sequence"     )   ,					id="references"     ),
                }     )   ,					codebase_urls=["https://github.com/Tiiiger/bert_score"]   ,					reference_urls=[
                "https://github.com/Tiiiger/bert_score",
                "https://arxiv.org/abs/1904.09675",
            ]   ,					)

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE=None   ,					__SCREAMING_SNAKE_CASE=None   ,					__SCREAMING_SNAKE_CASE=None   ,					__SCREAMING_SNAKE_CASE=False   ,					__SCREAMING_SNAKE_CASE=False   ,					__SCREAMING_SNAKE_CASE=None   ,					__SCREAMING_SNAKE_CASE=64   ,					__SCREAMING_SNAKE_CASE=4   ,					__SCREAMING_SNAKE_CASE=False   ,					__SCREAMING_SNAKE_CASE=False   ,					__SCREAMING_SNAKE_CASE=None   ,					__SCREAMING_SNAKE_CASE=False   ,					):






        '''simple docstring'''

        snake_case__    							=				bert_score.utils.get_hash
        snake_case__    							=				bert_score.BERTScorer

        if version.parse(bert_score.__version__     ) >= version.parse("0.3.10"     ):
         snake_case__    							=				functools.partial(A_   ,					use_fast_tokenizer=A_     )
         snake_case__    							=				functools.partial(A_   ,					use_fast_tokenizer=A_     )
        elif use_fast_tokenizer:
         raise ImportWarning(
             "To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of `bert-score` doesn't match this condition.\n"
             "You can install it with `pip install \"bert-score>=0.3.10\"`."     )

        if model_type is None:
         assert lang is not None, "either lang or model_type should be specified"
         snake_case__    							=				bert_score.utils.langamodel[lang.lower()]

        if num_layers is None:
         snake_case__    							=				bert_score.utils.modelalayers[model_type]

        snake_case__    							=				get_hash(
            model=A_   ,					num_layers=A_   ,					idf=A_   ,					rescale_with_baseline=A_   ,					use_custom_baseline=baseline_path is not None   ,					)

        with filter_logging_context():
         if not hasattr(self   ,					"cached_bertscorer"     ) or self.cached_bertscorer.hash != hashcode:
          snake_case__    							=				scorer(
              model_type=A_   ,					num_layers=A_   ,					batch_size=A_   ,					nthreads=A_   ,					all_layers=A_   ,					idf=A_   ,					device=A_   ,					lang=A_   ,					rescale_with_baseline=A_   ,					baseline_path=A_   ,					)

        ((snake_case__)							,   (snake_case__)							,   (snake_case__))    							=				self.cached_bertscorer.score(
            cands=A_   ,					refs=A_   ,					verbose=A_   ,					batch_size=A_   ,					)
        snake_case__    							=				{
            "precision": P.tolist(),
            "recall": R.tolist(),
            "f1": F.tolist(),
            "hashcode": hashcode,
        }
        return output_dict

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE=None   ,					__SCREAMING_SNAKE_CASE=None   ,					**__SCREAMING_SNAKE_CASE     ):






        '''simple docstring'''

        if references is not None:
         snake_case__    							=				[[ref] if isinstance(A_   ,					A_     ) else ref for ref in references]
        super().add_batch(predictions=A_   ,					references=A_   ,					**A_     )

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE=None   ,					__SCREAMING_SNAKE_CASE=None   ,					**__SCREAMING_SNAKE_CASE     ):






        '''simple docstring'''

        if isinstance(A_   ,					A_     ):
         snake_case__    							=				[reference]
        super().add(prediction=A_   ,					reference=A_   ,					**A_     )








"""simple docstring"""


import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
   from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import PoolFormerImageProcessor



class      lowercase_				(     __lowerCAmelCase							):

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				self.config_class(**self.inputs_dict     )
        self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE   ,					"hidden_sizes"     )     )
        self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE   ,					"num_encoder_blocks"     )     )



class      lowercase_				:

       def __init__(			self   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE=13   ,					__SCREAMING_SNAKE_CASE=64   ,					__SCREAMING_SNAKE_CASE=3   ,					__SCREAMING_SNAKE_CASE=4   ,					__SCREAMING_SNAKE_CASE=[2, 2, 2, 2]   ,					__SCREAMING_SNAKE_CASE=[8, 4, 2, 1]   ,					__SCREAMING_SNAKE_CASE=[16, 32, 64, 128]   ,					__SCREAMING_SNAKE_CASE=[1, 4, 8, 16]   ,					__SCREAMING_SNAKE_CASE=False   ,					__SCREAMING_SNAKE_CASE=True   ,					__SCREAMING_SNAKE_CASE="gelu"   ,					__SCREAMING_SNAKE_CASE=0.1   ,					__SCREAMING_SNAKE_CASE=0.02   ,					__SCREAMING_SNAKE_CASE=3   ,					__SCREAMING_SNAKE_CASE=None   ,					):






        '''simple docstring'''

        snake_case__    							=				parent
        snake_case__    							=				batch_size
        snake_case__    							=				image_size
        snake_case__    							=				num_channels
        snake_case__    							=				num_encoder_blocks
        snake_case__    							=				sr_ratios
        snake_case__    							=				depths
        snake_case__    							=				hidden_sizes
        snake_case__    							=				downsampling_rates
        snake_case__    							=				is_training
        snake_case__    							=				use_labels
        snake_case__    							=				hidden_act
        snake_case__    							=				hidden_dropout_prob
        snake_case__    							=				initializer_range
        snake_case__    							=				num_labels
        snake_case__    							=				scope

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

        snake_case__    							=				None
        if self.use_labels:
         snake_case__    							=				ids_tensor([self.batch_size, self.image_size, self.image_size]   ,					self.num_labels     )

        snake_case__    							=				PoolFormerConfig(
            image_size=self.image_size   ,					num_channels=self.num_channels   ,					num_encoder_blocks=self.num_encoder_blocks   ,					depths=self.depths   ,					hidden_sizes=self.hidden_sizes   ,					hidden_act=self.hidden_act   ,					hidden_dropout_prob=self.hidden_dropout_prob   ,					initializer_range=self.initializer_range   ,					)

        return config, pixel_values, labels

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE     ):






        '''simple docstring'''

        snake_case__    							=				PoolFormerModel(config=__SCREAMING_SNAKE_CASE     )
        model.to(__SCREAMING_SNAKE_CASE     )
        model.eval()
        snake_case__    							=				model(__SCREAMING_SNAKE_CASE     )
        snake_case__    							=				snake_case__    							=				self.image_size // 32.0
        self.parent.assertEqual(
            result.last_hidden_state.shape   ,					(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)     )

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				self.prepare_config_and_inputs()
        snake_case__							,   snake_case__							,   snake_case__    							=				config_and_inputs
        snake_case__    							=				{"pixel_values": pixel_values}
        return config, inputs_dict



@require_torch
class      lowercase_				(     __lowerCAmelCase				,__lowerCAmelCase				,unittest.TestCase							):
       snake_case__				:							Optional[Any]											=     (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
       snake_case__				:							Dict											=     (
           {"""feature-extraction""": PoolFormerModel, """image-classification""": PoolFormerForImageClassification}
           if is_torch_available()
           else {}
       )

       snake_case__				:							Optional[int]											=     False
       snake_case__				:							Optional[Any]											=     False
       snake_case__				:							List[Any]											=     False
       snake_case__				:							Any											=     False
       snake_case__				:							Tuple											=     False

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				PoolFormerModelTester(self     )
        snake_case__    							=				PoolFormerConfigTester(self   ,					config_class=__SCREAMING_SNAKE_CASE     )

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        self.config_tester.run_common_tests()

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )

       @unittest.skip("PoolFormer does not use inputs_embeds"     )
       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        pass

       @unittest.skip("PoolFormer does not have get_input_embeddings method and get_output_embeddings methods"     )
       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        pass

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        def check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE     ):
         snake_case__    							=				model_class(__SCREAMING_SNAKE_CASE     )
         model.to(__SCREAMING_SNAKE_CASE     )
         model.eval()

         with torch.no_grad():
          snake_case__    							=				model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE     )     )

         snake_case__    							=				outputs.hidden_states

         snake_case__    							=				self.model_tester.num_encoder_blocks
         self.assertEqual(len(__SCREAMING_SNAKE_CASE     )   ,					__SCREAMING_SNAKE_CASE     )

         # verify the first hidden states (first block)
         self.assertListEqual(
             list(hidden_states[0].shape[-3:]     )   ,					[
                 self.model_tester.hidden_sizes[0],
                 self.model_tester.image_size // 4,
                 self.model_tester.image_size // 4,
             ]   ,					)

        snake_case__							,   snake_case__    							=				self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case__    							=				True
         check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE     )

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

         check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE     )

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        if not self.model_tester.is_training:
         return

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

        for model_class in self.all_model_classes:
         if model_class in get_values(__SCREAMING_SNAKE_CASE     ):
          continue
         snake_case__    							=				model_class(__SCREAMING_SNAKE_CASE     )
         model.to(__SCREAMING_SNAKE_CASE     )
         model.train()
         snake_case__    							=				self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					return_labels=__SCREAMING_SNAKE_CASE     )
         snake_case__    							=				model(**__SCREAMING_SNAKE_CASE     ).loss
         loss.backward()

       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__							,   snake_case__    							=				self.model_tester.prepare_config_and_inputs_for_common()

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

         snake_case__    							=				["pixel_values"]
         self.assertListEqual(arg_names[:1]   ,					__SCREAMING_SNAKE_CASE     )

       @slow
       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         snake_case__    							=				PoolFormerModel.from_pretrained(__SCREAMING_SNAKE_CASE     )
         self.assertIsNotNone(__SCREAMING_SNAKE_CASE     )





def 							a__			(  )    ->  int:

 '''simple docstring'''






 snake_case__    							=				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
 return image



@require_torch
class      lowercase_				(     unittest.TestCase							):

       @slow
       def 		_SCREAMING_SNAKE_CASE(			self     ):






        '''simple docstring'''

        snake_case__    							=				PoolFormerImageProcessor()
        snake_case__    							=				PoolFormerForImageClassification.from_pretrained("sail/poolformer_s12"     ).to(__SCREAMING_SNAKE_CASE     )

        snake_case__    							=				image_processor(images=prepare_img()   ,					return_tensors="pt"     ).to(__SCREAMING_SNAKE_CASE     )

        # forward pass
        with torch.no_grad():
         snake_case__    							=				model(**__SCREAMING_SNAKE_CASE     )

        # verify the logits
        snake_case__    							=				torch.Size((1, 1000)     )
        self.assertEqual(outputs.logits.shape   ,					__SCREAMING_SNAKE_CASE     )

        snake_case__    							=				torch.tensor([-0.6113, 0.1685, -0.0492]     ).to(__SCREAMING_SNAKE_CASE     )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,					__SCREAMING_SNAKE_CASE   ,					atol=1e-4     )     )

