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







							'''simple docstring'''

							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]  ,  )					->       Tuple:
														_snake_case       =  parent
														_snake_case       =  batch_size
														_snake_case       =  image_size
														_snake_case       =  patch_size
														_snake_case       =  num_channels
														_snake_case       =  embed_dim
														_snake_case       =  hidden_sizes
														_snake_case       =  depths
														_snake_case       =  num_heads
														_snake_case       =  window_size
														_snake_case       =  mlp_ratio
														_snake_case       =  qkv_bias
														_snake_case       =  hidden_dropout_prob
														_snake_case       =  attention_probs_dropout_prob
														_snake_case       =  drop_path_rate
														_snake_case       =  hidden_act
														_snake_case       =  use_absolute_embeddings
														_snake_case       =  patch_norm
														_snake_case       =  layer_norm_eps
														_snake_case       =  initializer_range
														_snake_case       =  is_training
														_snake_case       =  scope
														_snake_case       =  use_labels
														_snake_case       =  type_sequence_label_size
														_snake_case       =  encoder_stride
														_snake_case       =  out_features
														_snake_case       =  out_indices

							def 	lowercase							(self  )					->       Union[str, Any]:
														_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.type_sequence_label_size  )

														_snake_case       =  self.get_config()

														return config, pixel_values, labels

							def 	lowercase							(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 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Dict:
														_snake_case       =  FocalNetModel(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  )

														_snake_case       =  ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
														_snake_case       =  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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       List[Any]:
														_snake_case       =  FocalNetBackbone(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  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
														_snake_case       =  None
														_snake_case       =  FocalNetBackbone(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Dict:
														_snake_case       =  FocalNetForMaskedImageModeling(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  )
														self.parent.assertEqual(
														    result.reconstruction.shape  ,  (self.batch_size, self.num_channels, self.image_size, self.image_size)  )

														# test greyscale images
														_snake_case       =  1
														_snake_case       =  FocalNetForMaskedImageModeling(UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()

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

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       int:
														_snake_case       =  self.type_sequence_label_size
														_snake_case       =  FocalNetForImageClassification(UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  labels=UpperCAmelCase  )
														self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.type_sequence_label_size)  )

														# test greyscale images
														_snake_case       =  1
														_snake_case       =  FocalNetForImageClassification(UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()

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





							def 	lowercase							(self  )					->       Any:
														_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       _lowerCAmelCase   (   __snake_case					,							__snake_case					,							unittest.TestCase				):







							'''simple docstring'''

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

							lowerCAmelCase_ 						=						False
							lowerCAmelCase_ 						=						False
							lowerCAmelCase_ 						=						False
							lowerCAmelCase_ 						=						False

							def 	lowercase							(self  )					->       Tuple:
														_snake_case       =  FocalNetModelTester(self  )
														_snake_case       =  ConfigTester(self  ,  config_class=UpperCAmelCase  ,  embed_dim=37  ,  has_text_modality=UpperCAmelCase  )

							def 	lowercase							(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 	lowercase							(self  )					->       Any:
														return

							def 	lowercase							(self  )					->       List[Any]:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       Dict:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_backbone(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       Tuple:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       List[str]:
														_snake_case       =  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  )					->       Any:
														pass

							def 	lowercase							(self  )					->       Union[str, Any]:
														_snake_case,							_snake_case       =  self.model_tester.prepare_config_and_inputs_for_common()

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

							def 	lowercase							(self  )					->       str:
														_snake_case,							_snake_case       =  self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes[:-1]:
																					_snake_case       =  model_class(UpperCAmelCase  )
																					_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]  ,  UpperCAmelCase  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Tuple:
														_snake_case       =  model_class(UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()

														with torch.no_grad():
																					_snake_case       =  model(**self._prepare_for_class(UpperCAmelCase  ,  UpperCAmelCase  )  )

														_snake_case       =  outputs.hidden_states

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

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

														_snake_case       =  outputs.reshaped_hidden_states
														self.assertEqual(len(UpperCAmelCase  )  ,  UpperCAmelCase  )

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

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

																					self.check_hidden_states_output(UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )

							def 	lowercase							(self  )					->       Dict:
														_snake_case,							_snake_case       =  self.model_tester.prepare_config_and_inputs_for_common()
														_snake_case       =  3

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

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

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

							@slow
							def 	lowercase							(self  )					->       Optional[int]:
														for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					_snake_case       =  FocalNetModel.from_pretrained(UpperCAmelCase  )
																					self.assertIsNotNone(UpperCAmelCase  )





							def 	lowercase							(self  )					->       Union[str, Any]:
														_snake_case,							_snake_case       =  self.model_tester.prepare_config_and_inputs_for_common()

														_snake_case       =  _config_zero_init(UpperCAmelCase  )
														for model_class in self.all_model_classes:
																					_snake_case       =  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       _lowerCAmelCase   (   unittest.TestCase				):







							'''simple docstring'''

							@cached_property
							def 	lowercase							(self  )					->       Union[str, Any]:
														# TODO update organization
														return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""  ) if is_vision_available() else None





							@slow
							def 	lowercase							(self  )					->       Dict:
														_snake_case       =  FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""  ).to(UpperCAmelCase  )
														_snake_case       =  self.default_image_processor

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

														# forward pass
														with torch.no_grad():
																					_snake_case       =  model(**UpperCAmelCase  )

														# verify the logits
														_snake_case       =  torch.Size((1, 1000)  )
														self.assertEqual(outputs.logits.shape  ,  UpperCAmelCase  )
														_snake_case       =  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()  ,  281  )


@require_torch
class       _lowerCAmelCase   (   __snake_case					,							unittest.TestCase				):







							'''simple docstring'''

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

							lowerCAmelCase_ 						=						False

							def 	lowercase							(self  )					->       Dict:
														_snake_case       =  FocalNetModelTester(self  )







'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__lowerCAmelCase												=	{
    'configuration_encodec': [
        'ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'EncodecConfig',
    ],
    'feature_extraction_encodec': ['EncodecFeatureExtractor'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'EncodecModel',
				    'EncodecPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_encodec import (
				    ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    EncodecConfig,
				)
				from .feature_extraction_encodec import EncodecFeatureExtractor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_encodec import (
								    ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
								    EncodecModel,
								    EncodecPreTrainedModel,
								)

else:
				import sys

				__lowerCAmelCase												=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)