



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


						'''simple docstring'''



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


						def     __snake_case   ( self				)     ->     Optional[Any]:
							lowerCAmelCase   =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

							lowerCAmelCase   =     self.get_config()

							return config, pixel_values, labels


						def     __snake_case   ( self				)     ->     Optional[Any]:
							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     __snake_case   ( self     ,	A_     ,	A_     ,	A_				)     ->     Any:
							lowerCAmelCase   =     FocalNetModel(config=_A				)
							model.to(_A				)
							model.eval()
							lowerCAmelCase   =     model(_A				)

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

							# test greyscale images
							lowerCAmelCase   =     1
							lowerCAmelCase   =     FocalNetForMaskedImageModeling(_A				)
							model.to(_A				)
							model.eval()

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


						def     __snake_case   ( self     ,	A_     ,	A_     ,	A_				)     ->     List[Any]:
							lowerCAmelCase   =     self.type_sequence_label_size
							lowerCAmelCase   =     FocalNetForImageClassification(_A				)
							model.to(_A				)
							model.eval()
							lowerCAmelCase   =     model(_A     ,	labels=_A				)
							self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.type_sequence_label_size)				)

							# test greyscale images
							lowerCAmelCase   =     1
							lowerCAmelCase   =     FocalNetForImageClassification(_A				)
							model.to(_A				)
							model.eval()

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




						def     __snake_case   ( self				)     ->     Dict:
							lowerCAmelCase   =     self.prepare_config_and_inputs()

							lowerCAmelCase,       lowerCAmelCase,       lowerCAmelCase   =     config_and_inputs
							lowerCAmelCase   =     {"""pixel_values""": pixel_values}
							return config, inputs_dict







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


						'''simple docstring'''



						UpperCAmelCase							:   Union[str, Any]									=		(
						    (
						        FocalNetModel,
						        FocalNetForImageClassification,
						        FocalNetForMaskedImageModeling,
						        FocalNetBackbone,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase							:   str									=		(
						    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
						    if is_torch_available()
						    else {}
						)
						UpperCAmelCase							:   Tuple									=		False

						UpperCAmelCase							:   str									=		False
						UpperCAmelCase							:   int									=		False
						UpperCAmelCase							:   Optional[Any]									=		False
						UpperCAmelCase							:   int									=		False


						def     __snake_case   ( self				)     ->     Optional[Any]:
							lowerCAmelCase   =     FocalNetModelTester(self				)
							lowerCAmelCase   =     ConfigTester(self     ,	config_class=_A     ,	embed_dim=37     ,	has_text_modality=_A				)


						def     __snake_case   ( self				)     ->     Union[str, Any]:
							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     __snake_case   ( self				)     ->     List[str]:
							return


						def     __snake_case   ( self				)     ->     Dict:
							lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_A				)


						def     __snake_case   ( self				)     ->     Union[str, Any]:
							lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*_A				)


						def     __snake_case   ( self				)     ->     Any:
							lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*_A				)


						def     __snake_case   ( self				)     ->     Union[str, Any]:
							lowerCAmelCase   =     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     __snake_case   ( self				)     ->     Optional[Any]:
							pass


						@unittest.skip(reason="""FocalNet does not use feedforward chunking"""				)
						def     __snake_case   ( self				)     ->     List[str]:
							pass


						def     __snake_case   ( self				)     ->     Dict:
							lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()

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


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

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

								lowerCAmelCase   =     ["""pixel_values"""]
								self.assertListEqual(arg_names[:1]     ,	_A				)


						def     __snake_case   ( self     ,	A_     ,	A_     ,	A_     ,	A_				)     ->     Union[str, Any]:
							lowerCAmelCase   =     model_class(_A				)
							model.to(_A				)
							model.eval()

							with torch.no_grad():
								lowerCAmelCase   =     model(**self._prepare_for_class(_A     ,	_A				)				)

							lowerCAmelCase   =     outputs.hidden_states

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

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

							lowerCAmelCase   =     outputs.reshaped_hidden_states
							self.assertEqual(len(_A				)     ,	_A				)

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

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

								self.check_hidden_states_output(_A     ,	_A     ,	_A     ,	_A				)


						def     __snake_case   ( self				)     ->     Tuple:
							lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()
							lowerCAmelCase   =     3

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

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

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


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



							for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								lowerCAmelCase   =     FocalNetModel.from_pretrained(_A				)
								self.assertIsNotNone(_A				)




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

							lowerCAmelCase   =     _config_zero_init(_A				)
							for model_class in self.all_model_classes:
								lowerCAmelCase   =     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 __snake_case(				unittest.TestCase ):


						'''simple docstring'''



						@cached_property
						def     __snake_case   ( self				)     ->     Optional[Any]:
							return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""				) if is_vision_available() else None




						@slow
						def     __snake_case   ( self				)     ->     Tuple:
							lowerCAmelCase   =     FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""				).to(_A				)
							lowerCAmelCase   =     self.default_image_processor

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

							# forward pass
							with torch.no_grad():
								lowerCAmelCase   =     model(**_A				)

							# verify the logits
							lowerCAmelCase   =     torch.Size((1, 1000)				)
							self.assertEqual(outputs.logits.shape     ,	_A				)
							lowerCAmelCase   =     torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]				).to(_A				)
							self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,	_A     ,	atol=1e-4				)				)
							self.assertTrue(outputs.logits.argmax(dim=-1				).item()     ,	281				)







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


						'''simple docstring'''



						UpperCAmelCase							:   int									=		(FocalNetBackbone,) if is_torch_available() else ()
						UpperCAmelCase							:   Tuple									=		FocalNetConfig

						UpperCAmelCase							:   int									=		False


						def     __snake_case   ( self				)     ->     str:
							lowerCAmelCase   =     FocalNetModelTester(self				)




'''simple docstring'''

import cmath
import math






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						float							,		_SCREAMING_SNAKE_CASE					:						float							,		_SCREAMING_SNAKE_CASE					:						float							,		_SCREAMING_SNAKE_CASE					:						float							)      ->						complex:







	"""simple docstring"""
	lowerCAmelCase   =     math.radians(_SCREAMING_SNAKE_CASE							)
	lowerCAmelCase   =     math.radians(_SCREAMING_SNAKE_CASE							)

	# Convert voltage and current to rectangular form
	lowerCAmelCase   =     cmath.rect(_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							)
	lowerCAmelCase   =     cmath.rect(_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							)

	# Calculate apparent power
	return voltage_rect * current_rect


if __name__ == "__main__":
				import doctest

				doctest.testmod()