




'''simple docstring'''


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  __lowercase    :







   def __init__(						self   ,				UpperCamelCase   ,				UpperCamelCase=13   ,				UpperCamelCase=32   ,				UpperCamelCase=2   ,				UpperCamelCase=3   ,				UpperCamelCase=16   ,				UpperCamelCase=[32, 64, 128]   ,				UpperCamelCase=[1, 2, 1]   ,				UpperCamelCase=[2, 2, 4]   ,				UpperCamelCase=2   ,				UpperCamelCase=2.0   ,				UpperCamelCase=True   ,				UpperCamelCase=0.0   ,				UpperCamelCase=0.0   ,				UpperCamelCase=0.1   ,				UpperCamelCase="gelu"   ,				UpperCamelCase=False   ,				UpperCamelCase=True   ,				UpperCamelCase=0.02   ,				UpperCamelCase=1e-5   ,				UpperCamelCase=True   ,				UpperCamelCase=None   ,				UpperCamelCase=True   ,				UpperCamelCase=10   ,				UpperCamelCase=8   ,				UpperCamelCase=["stage1", "stage2"]   ,				UpperCamelCase=[1, 2]   ,				)					->     List[Any]:
     __a								=       parent
     __a								=       batch_size
     __a								=       image_size
     __a								=       patch_size
     __a								=       num_channels
     __a								=       embed_dim
     __a								=       hidden_sizes
     __a								=       depths
     __a								=       num_heads
     __a								=       window_size
     __a								=       mlp_ratio
     __a								=       qkv_bias
     __a								=       hidden_dropout_prob
     __a								=       attention_probs_dropout_prob
     __a								=       drop_path_rate
     __a								=       hidden_act
     __a								=       use_absolute_embeddings
     __a								=       patch_norm
     __a								=       layer_norm_eps
     __a								=       initializer_range
     __a								=       is_training
     __a								=       scope
     __a								=       use_labels
     __a								=       type_sequence_label_size
     __a								=       encoder_stride
     __a								=       out_features
     __a								=       out_indices







   def 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

     __a								=       self.get_config()

     return config, pixel_values, labels







   def 		UpperCamelCase__      (						self   )					->     Optional[int]:
     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 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Optional[int]:
     __a								=       FocalNetModel(config=UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()
     __a								=       model(UpperCamelCase   )

     __a								=       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
     __a								=       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 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     str:
     __a								=       FocalNetBackbone(config=UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()
     __a								=       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
     __a								=       None
     __a								=       FocalNetBackbone(config=UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()
     __a								=       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 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Any:
     __a								=       FocalNetForMaskedImageModeling(config=UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()
     __a								=       model(UpperCamelCase   )
     self.parent.assertEqual(
         result.reconstruction.shape   ,				(self.batch_size, self.num_channels, self.image_size, self.image_size)   )

     # test greyscale images
     __a								=       1
     __a								=       FocalNetForMaskedImageModeling(UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()

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







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Dict:
     __a								=       self.type_sequence_label_size
     __a								=       FocalNetForImageClassification(UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()
     __a								=       model(UpperCamelCase   ,				labels=UpperCamelCase   )
     self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.type_sequence_label_size)   )

     # test greyscale images
     __a								=       1
     __a								=       FocalNetForImageClassification(UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()

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







   def 		UpperCamelCase__      (						self   )					->     Dict:
     __a								=       self.prepare_config_and_inputs()

     __a						,							__a						,							__a								=       config_and_inputs
     __a								=       {'pixel_values': pixel_values}
     return config, inputs_dict





@require_torch
class  __lowercase    (	__magic_name__							,				__magic_name__							,				unittest.TestCase			):
   _a    						=   (
       (
           FocalNetModel,
           FocalNetForImageClassification,
           FocalNetForMaskedImageModeling,
           FocalNetBackbone,
       )
       if is_torch_available()
       else ()
   )
   _a    						=   (
       {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
       if is_torch_available()
       else {}
   )
   _a    						=   False

   _a    						=   False
   _a    						=   False
   _a    						=   False
   _a    						=   False







   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     __a								=       FocalNetModelTester(self   )
     __a								=       ConfigTester(self   ,				config_class=UpperCamelCase   ,				embed_dim=37   ,				has_text_modality=UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     str:
     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 		UpperCamelCase__      (						self   )					->     Optional[int]:
     return







   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     __a								=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     __a								=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     Dict:
     __a								=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_image_modeling(*UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     int:
     __a								=       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 		UpperCamelCase__      (						self   )					->     int:
     pass







   @unittest.skip(reason='FocalNet does not use feedforward chunking'   )
   def 		UpperCamelCase__      (						self   )					->     Any:
     pass







   def 		UpperCamelCase__      (						self   )					->     Optional[int]:
     __a						,							__a								=       self.model_tester.prepare_config_and_inputs_for_common()

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







   def 		UpperCamelCase__      (						self   )					->     str:
     __a						,							__a								=       self.model_tester.prepare_config_and_inputs_for_common()

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

       __a								=       ['pixel_values']
       self.assertListEqual(arg_names[:1]   ,				UpperCamelCase   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     str:
     __a								=       model_class(UpperCamelCase   )
     model.to(UpperCamelCase   )
     model.eval()

     with torch.no_grad():
       __a								=       model(**self._prepare_for_class(UpperCamelCase   ,				UpperCamelCase   )   )

     __a								=       outputs.hidden_states

     __a								=       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
     __a								=       (
         config.patch_size
         if isinstance(config.patch_size   ,				collections.abc.Iterable   )
         else (config.patch_size, config.patch_size)
     )

     __a								=       (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]   ,				)

     __a								=       outputs.reshaped_hidden_states
     self.assertEqual(len(UpperCamelCase   )   ,				UpperCamelCase   )

     __a						,							__a						,							__a						,							__a								=       reshaped_hidden_states[0].shape
     __a								=       (
         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 		UpperCamelCase__      (						self   )					->     Any:
     __a						,							__a								=       self.model_tester.prepare_config_and_inputs_for_common()

     __a								=       (
         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]:
       __a								=       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"]
       __a								=       True

       self.check_hidden_states_output(UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     str:
     __a						,							__a								=       self.model_tester.prepare_config_and_inputs_for_common()
     __a								=       3

     __a								=       (
         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)
     )
     __a								=       (
         config.patch_size
         if isinstance(config.patch_size   ,				collections.abc.Iterable   )
         else (config.patch_size, config.patch_size)
     )

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

     for model_class in self.all_model_classes[:-1]:
       __a								=       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"]
       __a								=       True
       self.check_hidden_states_output(UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   ,				(padded_height, padded_width)   )







   @slow
   def 		UpperCamelCase__      (						self   )					->     int:
     for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __a								=       FocalNetModel.from_pretrained(UpperCamelCase   )
       self.assertIsNotNone(UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     __a						,							__a								=       self.model_tester.prepare_config_and_inputs_for_common()

     __a								=       _config_zero_init(UpperCamelCase   )
     for model_class in self.all_model_classes:
       __a								=       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  __lowercase    (	unittest.TestCase			):







   @cached_property
   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     # TODO update organization
     return AutoImageProcessor.from_pretrained('microsoft/focalnet-tiny'   ) if is_vision_available() else None







   @slow
   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     __a								=       FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'   ).to(UpperCamelCase   )
     __a								=       self.default_image_processor

     __a								=       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
     __a								=       image_processor(images=UpperCamelCase   ,				return_tensors='pt'   ).to(UpperCamelCase   )

     # forward pass
     with torch.no_grad():
       __a								=       model(**UpperCamelCase   )

     # verify the logits
     __a								=       torch.Size((1, 1000)   )
     self.assertEqual(outputs.logits.shape   ,				UpperCamelCase   )
     __a								=       torch.tensor([0.2_166, -0.4_368, 0.2_191]   ).to(UpperCamelCase   )
     self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,				UpperCamelCase   ,				atol=1e-4   )   )
     self.assertTrue(outputs.logits.argmax(dim=-1   ).item()   ,				281   )





@require_torch
class  __lowercase    (	__magic_name__							,				unittest.TestCase			):
   _a    						=   (FocalNetBackbone,) if is_torch_available() else ()
   _a    						=   FocalNetConfig

   _a    						=   False







   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     __a								=       FocalNetModelTester(self   )









'''simple docstring'''


import logging
import os
import sys
from pathlib import Path
from unittest.mock import patch

from parameterized import parameterized
from run_eval import run_generate
from run_eval_search import run_search

from transformers.testing_utils import CaptureStdout, TestCasePlus, slow
from utils import ROUGE_KEYS


logging.basicConfig(level=logging.DEBUG)
UpperCAmelCase_					=   logging.getLogger()


def     SCREAMING_SNAKE_CASE							(   a_						:				Path					,       a_						:				list      ):
  __a								=       '\n'.join(a_      )
  Path(a_      ).open('w'      ).writelines(a_      )


UpperCAmelCase_					=   "patrickvonplaten/t5-tiny-random"
UpperCAmelCase_					=   "sshleifer/bart-tiny-random"
UpperCAmelCase_					=   "sshleifer/tiny-mbart"

UpperCAmelCase_					=   logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks





class  __lowercase    (	__magic_name__			):







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Dict:
     __a								=       Path(self.get_auto_remove_tmp_dir()   ) / 'utest_input.source'
     __a								=       input_file_name.parent / 'utest_output.txt'
     assert not output_file_name.exists()
     __a								=       [' New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County.']
     _dump_articles(UpperCamelCase   ,				UpperCamelCase   )

     __a								=       str(Path(self.get_auto_remove_tmp_dir()   ) / 'scores.json'   )
     __a								=       'translation_en_to_de' if model == T5_TINY else 'summarization'
     __a								=       f"\n            run_eval_search.py\n            {model}\n            {input_file_name}\n            {output_file_name}\n            --score_path {score_path}\n            --task {task}\n            --num_beams 2\n            --length_penalty 2.0\n            ".split()

     with patch.object(UpperCamelCase   ,				'argv'   ,				UpperCamelCase   ):
       run_generate()
       assert Path(UpperCamelCase   ).exists()
       # os.remove(Path(output_file_name))







   def 		UpperCamelCase__      (						self   )					->     int:
     self.run_eval_tester(UpperCamelCase   )







   @parameterized.expand([BART_TINY, MBART_TINY]   )
   @slow
   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Union[str, Any]:
     self.run_eval_tester(UpperCamelCase   )







   @parameterized.expand([T5_TINY, MBART_TINY]   )
   @slow
   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Optional[Any]:
     __a								=       Path(self.get_auto_remove_tmp_dir()   ) / 'utest_input.source'
     __a								=       input_file_name.parent / 'utest_output.txt'
     assert not output_file_name.exists()

     __a								=       {
         'en': ['Machine learning is great, isn\'t it?', 'I like to eat bananas', 'Tomorrow is another great day!'],
         'de': [
             'Maschinelles Lernen ist großartig, oder?',
             'Ich esse gerne Bananen',
             'Morgen ist wieder ein toller Tag!',
         ],
     }

     __a								=       Path(self.get_auto_remove_tmp_dir()   )
     __a								=       str(tmp_dir / 'scores.json'   )
     __a								=       str(tmp_dir / 'val.target'   )
     _dump_articles(UpperCamelCase   ,				text['en']   )
     _dump_articles(UpperCamelCase   ,				text['de']   )
     __a								=       'translation_en_to_de' if model == T5_TINY else 'summarization'
     __a								=       f"\n            run_eval_search.py\n            {model}\n            {str(UpperCamelCase   )}\n            {str(UpperCamelCase   )}\n            --score_path {score_path}\n            --reference_path {reference_path}\n            --task {task}\n            ".split()
     testargs.extend(['--search', 'num_beams=1:2 length_penalty=0.9:1.0']   )

     with patch.object(UpperCamelCase   ,				'argv'   ,				UpperCamelCase   ):
       with CaptureStdout() as cs:
         run_search()
       __a								=       [' num_beams | length_penalty', model, 'Best score args']
       __a								=       ['Info']
       if "translation" in task:
         expected_strings.append('bleu'   )
       else:
         expected_strings.extend(UpperCamelCase   )
       for w in expected_strings:
         assert w in cs.out
       for w in un_expected_strings:
         assert w not in cs.out
       assert Path(UpperCamelCase   ).exists()
       os.remove(Path(UpperCamelCase   )   )



