




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

						def __init__(		self   :int    , __snake_case   :Union[str, Any]    , __snake_case   :Optional[int]=13    , __snake_case   :Dict=32    , __snake_case   :str=2    , __snake_case   :Tuple=3    , __snake_case   :Tuple=16    , __snake_case   :Union[str, Any]=[32, 64, 1_28]    , __snake_case   :Tuple=[1, 2, 1]    , __snake_case   :Optional[Any]=[2, 2, 4]    , __snake_case   :Dict=2    , __snake_case   :str=2.0    , __snake_case   :List[Any]=True    , __snake_case   :Union[str, Any]=0.0    , __snake_case   :int=0.0    , __snake_case   :List[Any]=0.1    , __snake_case   :Any="gelu"    , __snake_case   :Tuple=False    , __snake_case   :List[Any]=True    , __snake_case   :Dict=0.02    , __snake_case   :Tuple=1E-5    , __snake_case   :Tuple=True    , __snake_case   :Optional[int]=None    , __snake_case   :Tuple=True    , __snake_case   :Dict=10    , __snake_case   :Any=8    , __snake_case   :int=["stage1", "stage2"]    , __snake_case   :List[Any]=[1, 2]    , ):
										'''simple docstring'''

										__magic_name__	:	Union[str, Any]								=parent
										__magic_name__	:	List[str]								=batch_size
										__magic_name__	:	str								=image_size
										__magic_name__	:	List[Any]								=patch_size
										__magic_name__	:	Optional[Any]								=num_channels
										__magic_name__	:	Any								=embed_dim
										__magic_name__	:	List[str]								=hidden_sizes
										__magic_name__	:	Optional[int]								=depths
										__magic_name__	:	Tuple								=num_heads
										__magic_name__	:	Tuple								=window_size
										__magic_name__	:	Dict								=mlp_ratio
										__magic_name__	:	List[str]								=qkv_bias
										__magic_name__	:	int								=hidden_dropout_prob
										__magic_name__	:	Dict								=attention_probs_dropout_prob
										__magic_name__	:	Union[str, Any]								=drop_path_rate
										__magic_name__	:	Optional[Any]								=hidden_act
										__magic_name__	:	Optional[int]								=use_absolute_embeddings
										__magic_name__	:	List[Any]								=patch_norm
										__magic_name__	:	str								=layer_norm_eps
										__magic_name__	:	List[Any]								=initializer_range
										__magic_name__	:	List[Any]								=is_training
										__magic_name__	:	Dict								=scope
										__magic_name__	:	int								=use_labels
										__magic_name__	:	Optional[Any]								=type_sequence_label_size
										__magic_name__	:	Union[str, Any]								=encoder_stride
										__magic_name__	:	Optional[Any]								=out_features
										__magic_name__	:	str								=out_indices

						def     A__						(		self   :Any ):
										'''simple docstring'''

										__magic_name__	:	Tuple								=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

										__magic_name__	:	Tuple								=None
										if self.use_labels:
														__magic_name__	:	List[str]								=ids_tensor([self.batch_size]    , self.type_sequence_label_size )

										__magic_name__	:	List[Any]								=self.get_config()

										return config, pixel_values, labels

						def     A__						(		self   :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   :Optional[int]    , __snake_case   :int    , __snake_case   :Optional[int]    , __snake_case   :List[str] ):
										'''simple docstring'''

										__magic_name__	:	List[Any]								=FocalNetModel(config=__snake_case )
										model.to(__snake_case )
										model.eval()
										__magic_name__	:	int								=model(__snake_case )

										__magic_name__	:	str								=((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
										__magic_name__	:	Optional[int]								=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   :Dict    , __snake_case   :Tuple    , __snake_case   :Dict    , __snake_case   :Optional[Any] ):
										'''simple docstring'''

										__magic_name__	:	int								=FocalNetBackbone(config=__snake_case )
										model.to(__snake_case )
										model.eval()
										__magic_name__	:	str								=model(__snake_case )

										# 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
										__magic_name__	:	int								=None
										__magic_name__	:	str								=FocalNetBackbone(config=__snake_case )
										model.to(__snake_case )
										model.eval()
										__magic_name__	:	Union[str, Any]								=model(__snake_case )

										# 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   :int    , __snake_case   :Tuple    , __snake_case   :Optional[int]    , __snake_case   :Dict ):
										'''simple docstring'''

										__magic_name__	:	Optional[int]								=FocalNetForMaskedImageModeling(config=__snake_case )
										model.to(__snake_case )
										model.eval()
										__magic_name__	:	Tuple								=model(__snake_case )
										self.parent.assertEqual(
										    result.reconstruction.shape    , (self.batch_size, self.num_channels, self.image_size, self.image_size) )

										# test greyscale images
										__magic_name__	:	int								=1
										__magic_name__	:	Dict								=FocalNetForMaskedImageModeling(__snake_case )
										model.to(__snake_case )
										model.eval()

										__magic_name__	:	List[str]								=floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
										__magic_name__	:	str								=model(__snake_case )
										self.parent.assertEqual(result.reconstruction.shape    , (self.batch_size, 1, self.image_size, self.image_size) )

						def     A__						(		self   :Tuple    , __snake_case   :int    , __snake_case   :Union[str, Any]    , __snake_case   :Union[str, Any] ):
										'''simple docstring'''

										__magic_name__	:	Any								=self.type_sequence_label_size
										__magic_name__	:	int								=FocalNetForImageClassification(__snake_case )
										model.to(__snake_case )
										model.eval()
										__magic_name__	:	List[Any]								=model(__snake_case    , labels=__snake_case )
										self.parent.assertEqual(result.logits.shape    , (self.batch_size, self.type_sequence_label_size) )

										# test greyscale images
										__magic_name__	:	int								=1
										__magic_name__	:	int								=FocalNetForImageClassification(__snake_case )
										model.to(__snake_case )
										model.eval()

										__magic_name__	:	List[Any]								=floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
										__magic_name__	:	int								=model(__snake_case )
										self.parent.assertEqual(result.logits.shape    , (self.batch_size, self.type_sequence_label_size) )


						def     A__						(		self   :int ):
										'''simple docstring'''

										__magic_name__	:	Optional[int]								=self.prepare_config_and_inputs()

										__magic_name__	:	Any								=config_and_inputs
										__magic_name__	:	str								={"""pixel_values""": pixel_values}
										return config, inputs_dict




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

						UpperCamelCase     						=					False
						UpperCamelCase     						=					False
						UpperCamelCase     						=					False
						UpperCamelCase     						=					False

						def     A__						(		self   :Optional[int] ):
										'''simple docstring'''

										__magic_name__	:	Optional[int]								=FocalNetModelTester(self )
										__magic_name__	:	List[str]								=ConfigTester(self    , config_class=__snake_case    , embed_dim=37    , has_text_modality=__snake_case )

						def     A__						(		self   :str ):
										'''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   :Union[str, Any] ):
										'''simple docstring'''

										return

						def     A__						(		self   :Tuple ):
										'''simple docstring'''

										__magic_name__	:	List[str]								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__snake_case )

						def     A__						(		self   :List[Any] ):
										'''simple docstring'''

										__magic_name__	:	Union[str, Any]								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*__snake_case )

						def     A__						(		self   :List[Any] ):
										'''simple docstring'''

										__magic_name__	:	Optional[Any]								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*__snake_case )

						def     A__						(		self   :List[Any] ):
										'''simple docstring'''

										__magic_name__	:	Optional[Any]								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*__snake_case )

						@unittest.skip(reason="""FocalNet does not use inputs_embeds""" )
						def     A__						(		self   :Optional[int] ):
										'''simple docstring'''

										pass

						@unittest.skip(reason="""FocalNet does not use feedforward chunking""" )
						def     A__						(		self   :List[Any] ):
										'''simple docstring'''

										pass

						def     A__						(		self   :Any ):
										'''simple docstring'''

										__magic_name__	:	Dict								=self.model_tester.prepare_config_and_inputs_for_common()

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

						def     A__						(		self   :Union[str, Any] ):
										'''simple docstring'''

										__magic_name__	:	str								=self.model_tester.prepare_config_and_inputs_for_common()

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

														__magic_name__	:	int								=["""pixel_values"""]
														self.assertListEqual(arg_names[:1]    , __snake_case )

						def     A__						(		self   :Dict    , __snake_case   :Tuple    , __snake_case   :Dict    , __snake_case   :Dict    , __snake_case   :Any ):
										'''simple docstring'''

										__magic_name__	:	List[str]								=model_class(__snake_case )
										model.to(__snake_case )
										model.eval()

										with torch.no_grad():
														__magic_name__	:	str								=model(**self._prepare_for_class(__snake_case    , __snake_case ) )

										__magic_name__	:	str								=outputs.hidden_states

										__magic_name__	:	Dict								=getattr(
										    self.model_tester    , """expected_num_hidden_layers"""    , len(self.model_tester.depths ) + 1 )
										self.assertEqual(len(__snake_case )    , __snake_case )

										# FocalNet has a different seq_length
										__magic_name__	:	int								=(
										    config.patch_size
										    if isinstance(config.patch_size    , collections.abc.Iterable )
										    else (config.patch_size, config.patch_size)
										)

										__magic_name__	:	Dict								=(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]    , )

										__magic_name__	:	Dict								=outputs.reshaped_hidden_states
										self.assertEqual(len(__snake_case )    , __snake_case )

										__magic_name__	:	Optional[Any]								=reshaped_hidden_states[0].shape
										__magic_name__	:	List[Any]								=(
										    reshaped_hidden_states[0].view(__snake_case    , __snake_case    , 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] ):
										'''simple docstring'''

										__magic_name__	:	str								=self.model_tester.prepare_config_and_inputs_for_common()

										__magic_name__	:	Any								=(
										    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]:
														__magic_name__	:	Optional[int]								=True
														self.check_hidden_states_output(__snake_case    , __snake_case    , __snake_case    , __snake_case )

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														__magic_name__	:	Optional[Any]								=True

														self.check_hidden_states_output(__snake_case    , __snake_case    , __snake_case    , __snake_case )

						def     A__						(		self   :List[Any] ):
										'''simple docstring'''

										__magic_name__	:	int								=self.model_tester.prepare_config_and_inputs_for_common()
										__magic_name__	:	List[Any]								=3

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

										__magic_name__	:	int								=image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
										__magic_name__	:	int								=image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

										for model_class in self.all_model_classes[:-1]:
														__magic_name__	:	List[str]								=True
														self.check_hidden_states_output(__snake_case    , __snake_case    , __snake_case    , (padded_height, padded_width) )

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														__magic_name__	:	Optional[int]								=True
														self.check_hidden_states_output(__snake_case    , __snake_case    , __snake_case    , (padded_height, padded_width) )

						@slow
						def     A__						(		self   :str ):
										'''simple docstring'''

										for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														__magic_name__	:	Optional[Any]								=FocalNetModel.from_pretrained(__snake_case )
														self.assertIsNotNone(__snake_case )


						def     A__						(		self   :int ):
										'''simple docstring'''

										__magic_name__	:	Optional[Any]								=self.model_tester.prepare_config_and_inputs_for_common()

										__magic_name__	:	Optional[int]								=_config_zero_init(__snake_case )
										for model_class in self.all_model_classes:
														__magic_name__	:	List[str]								=model_class(config=__snake_case )
														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 		__A      (			unittest.TestCase			):

						@cached_property
						def     A__						(		self   :Tuple ):
										'''simple docstring'''

										return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny""" ) if is_vision_available() else None


						@slow
						def     A__						(		self   :Any ):
										'''simple docstring'''

										__magic_name__	:	List[str]								=FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny""" ).to(__snake_case )
										__magic_name__	:	str								=self.default_image_processor

										__magic_name__	:	List[Any]								=Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
										__magic_name__	:	Dict								=image_processor(images=__snake_case    , return_tensors="""pt""" ).to(__snake_case )

										# forward pass
										with torch.no_grad():
														__magic_name__	:	Tuple								=model(**__snake_case )

										# verify the logits
										__magic_name__	:	Optional[Any]								=torch.Size((1, 10_00) )
										self.assertEqual(outputs.logits.shape    , __snake_case )
										__magic_name__	:	Dict								=torch.tensor([0.2166, -0.4368, 0.2191] ).to(__snake_case )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]    , __snake_case    , atol=1E-4 ) )
										self.assertTrue(outputs.logits.argmax(dim=-1 ).item()    , 2_81 )




@require_torch
class 		__A      (			UpperCamelCase__					,						unittest.TestCase			):
						UpperCamelCase     						=					(FocalNetBackbone,) if is_torch_available() else ()
						UpperCamelCase     						=					FocalNetConfig

						UpperCamelCase     						=					False

						def     A__						(		self   :Optional[Any] ):
										'''simple docstring'''

										__magic_name__	:	Optional[Any]								=FocalNetModelTester(self )










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_		:				Dict									=     {"configuration_wavlm": ["WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "WavLMConfig"]}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase_		:				Optional[int]									=     [
							    "WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "WavLMForAudioFrameClassification",
							    "WavLMForCTC",
							    "WavLMForSequenceClassification",
							    "WavLMForXVector",
							    "WavLMModel",
							    "WavLMPreTrainedModel",
							]

if TYPE_CHECKING:
							from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_wavlm import (
														    WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST,
														    WavLMForAudioFrameClassification,
														    WavLMForCTC,
														    WavLMForSequenceClassification,
														    WavLMForXVector,
														    WavLMModel,
														    WavLMPreTrainedModel,
														)

else:
							import sys

							UpperCAmelCase_		:				Union[str, Any]									=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




