






'''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      UpperCamelCase :







		"""simple docstring"""



		def __init__(  self		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       int=1_3						,_SCREAMING_SNAKE_CASE		:       List[Any]=3_2						,_SCREAMING_SNAKE_CASE		:       Tuple=2						,_SCREAMING_SNAKE_CASE		:       Tuple=3						,_SCREAMING_SNAKE_CASE		:       List[Any]=1_6						,_SCREAMING_SNAKE_CASE		:       Optional[Any]=[3_2, 6_4, 1_2_8]						,_SCREAMING_SNAKE_CASE		:       Optional[int]=[1, 2, 1]						,_SCREAMING_SNAKE_CASE		:       Dict=[2, 2, 4]						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]=2						,_SCREAMING_SNAKE_CASE		:       Optional[Any]=2.0						,_SCREAMING_SNAKE_CASE		:       Optional[int]=True						,_SCREAMING_SNAKE_CASE		:       Dict=0.0						,_SCREAMING_SNAKE_CASE		:       Optional[int]=0.0						,_SCREAMING_SNAKE_CASE		:       Dict=0.1						,_SCREAMING_SNAKE_CASE		:       Any="gelu"						,_SCREAMING_SNAKE_CASE		:       Dict=False						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]=True						,_SCREAMING_SNAKE_CASE		:       List[Any]=0.02						,_SCREAMING_SNAKE_CASE		:       Dict=1E-5						,_SCREAMING_SNAKE_CASE		:       List[Any]=True						,_SCREAMING_SNAKE_CASE		:       Optional[Any]=None						,_SCREAMING_SNAKE_CASE		:       List[str]=True						,_SCREAMING_SNAKE_CASE		:       int=1_0						,_SCREAMING_SNAKE_CASE		:       Dict=8						,_SCREAMING_SNAKE_CASE		:       Any=["stage1", "stage2"]						,_SCREAMING_SNAKE_CASE		:       List[str]=[1, 2]						,)    ->   Any:


						'''simple docstring'''
						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       A(  self		:       List[str]		)    ->   List[Any]:


						'''simple docstring'''
						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       A(  self		:       Any		)    ->   Optional[Any]:


						'''simple docstring'''
						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       A(  self		:       str						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       Dict						,_SCREAMING_SNAKE_CASE		:       Tuple		)    ->   int:


						'''simple docstring'''
						A	 =      FocalNetModel(config=__a		)
						model.to(__a		)
						model.eval()
						A	 =      model(__a		)

						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       A(  self		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Any						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]		)    ->   int:


						'''simple docstring'''
						A	 =      FocalNetBackbone(config=__a		)
						model.to(__a		)
						model.eval()
						A	 =      model(__a		)

						# 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=__a		)
						model.to(__a		)
						model.eval()
						A	 =      model(__a		)

						# 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       A(  self		:       str						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Dict						,_SCREAMING_SNAKE_CASE		:       int		)    ->   Dict:


						'''simple docstring'''
						A	 =      FocalNetForMaskedImageModeling(config=__a		)
						model.to(__a		)
						model.eval()
						A	 =      model(__a		)
						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(__a		)
						model.to(__a		)
						model.eval()

						A	 =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
						A	 =      model(__a		)
						self.parent.assertEqual(result.reconstruction.shape						,(self.batch_size, 1, self.image_size, self.image_size)		)
		def       A(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       Dict						,_SCREAMING_SNAKE_CASE		:       int		)    ->   Optional[Any]:


						'''simple docstring'''
						A	 =      self.type_sequence_label_size
						A	 =      FocalNetForImageClassification(__a		)
						model.to(__a		)
						model.eval()
						A	 =      model(__a						,labels=__a		)
						self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.type_sequence_label_size)		)

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

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







		def       A(  self		:       str		)    ->   List[str]:


						'''simple docstring'''
						A	 =      self.prepare_config_and_inputs()

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


@require_torch
class      UpperCamelCase (				snake_case__			,       snake_case__			,       unittest.TestCase ):







		"""simple docstring"""



		snake_case    =   (
		    (
		        FocalNetModel,
		        FocalNetForImageClassification,
		        FocalNetForMaskedImageModeling,
		        FocalNetBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		snake_case    =   (
		    {"feature-extraction": FocalNetModel, "image-classification": FocalNetForImageClassification}
		    if is_torch_available()
		    else {}
		)
		snake_case    =   False

		snake_case    =   False
		snake_case    =   False
		snake_case    =   False
		snake_case    =   False
		def       A(  self		:       Optional[Any]		)    ->   Union[str, Any]:


						'''simple docstring'''
						A	 =      FocalNetModelTester(self		)
						A	 =      ConfigTester(self						,config_class=__a						,embed_dim=3_7						,has_text_modality=__a		)
		def       A(  self		:       Tuple		)    ->   Union[str, Any]:


						'''simple docstring'''
						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       A(  self		:       Any		)    ->   str:


						'''simple docstring'''
						return
		def       A(  self		:       int		)    ->   List[Any]:


						'''simple docstring'''
						A	 =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__a		)
		def       A(  self		:       Dict		)    ->   Optional[int]:


						'''simple docstring'''
						A	 =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_backbone(*__a		)
		def       A(  self		:       List[Any]		)    ->   Tuple:


						'''simple docstring'''
						A	 =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*__a		)
		def       A(  self		:       int		)    ->   str:


						'''simple docstring'''
						A	 =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__a		)
		@unittest.skip(reason='FocalNet does not use inputs_embeds'		)
		def       A(  self		:       List[str]		)    ->   Dict:


						'''simple docstring'''
						pass
		@unittest.skip(reason='FocalNet does not use feedforward chunking'		)
		def       A(  self		:       int		)    ->   Optional[int]:


						'''simple docstring'''
						pass
		def       A(  self		:       Tuple		)    ->   Union[str, Any]:


						'''simple docstring'''
						A ,		A	 =      self.model_tester.prepare_config_and_inputs_for_common()

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


						'''simple docstring'''
						A ,		A	 =      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes[:-1]:
										A	 =      model_class(__a		)
										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]						,__a		)
		def       A(  self		:       int						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   Optional[Any]:


						'''simple docstring'''
						A	 =      model_class(__a		)
						model.to(__a		)
						model.eval()

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

						A	 =      outputs.hidden_states

						A	 =      getattr(
						    self.model_tester						,'expected_num_hidden_layers'						,len(self.model_tester.depths		) + 1		)
						self.assertEqual(len(__a		)						,__a		)

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

						A ,		A ,		A ,		A	 =      reshaped_hidden_states[0].shape
						A	 =      (
						    reshaped_hidden_states[0].view(__a						,__a						,height * width		).permute(0						,2						,1		)
						)
						self.assertListEqual(
						    list(reshaped_hidden_states.shape[-2:]		)						,[num_patches, self.model_tester.embed_dim]						,)
		def       A(  self		:       Union[str, Any]		)    ->   List[str]:


						'''simple docstring'''
						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(__a						,__a						,__a						,__a		)

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

										self.check_hidden_states_output(__a						,__a						,__a						,__a		)
		def       A(  self		:       str		)    ->   List[Any]:


						'''simple docstring'''
						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(__a						,__a						,__a						,(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(__a						,__a						,__a						,(padded_height, padded_width)		)
		@slow
		def       A(  self		:       str		)    ->   str:


						'''simple docstring'''
						for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										A	 =      FocalNetModel.from_pretrained(__a		)
										self.assertIsNotNone(__a		)







		def       A(  self		:       Any		)    ->   List[Any]:


						'''simple docstring'''
						A ,		A	 =      self.model_tester.prepare_config_and_inputs_for_common()

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







		"""simple docstring"""



		@cached_property
		def       A(  self		:       Optional[int]		)    ->   str:


						'''simple docstring'''
						return AutoImageProcessor.from_pretrained('microsoft/focalnet-tiny'		) if is_vision_available() else None







		@slow
		def       A(  self		:       Optional[Any]		)    ->   Optional[int]:


						'''simple docstring'''
						A	 =      FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'		).to(__a		)
						A	 =      self.default_image_processor

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

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

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


@require_torch
class      UpperCamelCase (				snake_case__			,       unittest.TestCase ):







		"""simple docstring"""



		snake_case    =   (FocalNetBackbone,) if is_torch_available() else ()
		snake_case    =   FocalNetConfig

		snake_case    =   False
		def       A(  self		:       Tuple		)    ->   int:


						'''simple docstring'''
						A	 =      FocalNetModelTester(self		)













import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
lowerCAmelCase_           = '.'


if __name__ == "__main__":
					lowerCAmelCase_           = os.path.join(REPO_PATH, 'utils/documentation_tests.txt')
					lowerCAmelCase_           = []
					lowerCAmelCase_           = []
					with open(doctest_file_path) as fp:
										for line in fp:
															lowerCAmelCase_           = line.strip()
															lowerCAmelCase_           = os.path.join(REPO_PATH, line)
															if not (os.path.isfile(path) or os.path.isdir(path)):
																				non_existent_paths.append(line)
															all_paths.append(path)
					if len(non_existent_paths) > 0:
										lowerCAmelCase_           = '\n'.join(non_existent_paths)
										raise ValueError(f'''`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}''')
					if all_paths != sorted(all_paths):
										raise ValueError('Files in `utils/documentation_tests.txt` are not in alphabetical order.')





