
import collections
import inspect
import unittest

from transformers import SwinConfig
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 SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
					from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor
class 			lowercase__:



	"""simple docstring"""




	def __init__(	self  :      Tuple	,							SCREAMING_SNAKE_CASE_  :      Any	,							SCREAMING_SNAKE_CASE_  :      Dict=1_3	,							SCREAMING_SNAKE_CASE_  :      List[Any]=3_2	,							SCREAMING_SNAKE_CASE_  :      Any=2	,							SCREAMING_SNAKE_CASE_  :      Tuple=3	,							SCREAMING_SNAKE_CASE_  :      Dict=1_6	,							SCREAMING_SNAKE_CASE_  :      Optional[int]=[1, 2, 1]	,							SCREAMING_SNAKE_CASE_  :      List[str]=[2, 2, 4]	,							SCREAMING_SNAKE_CASE_  :      int=2	,							SCREAMING_SNAKE_CASE_  :      Optional[int]=2.0	,							SCREAMING_SNAKE_CASE_  :      Dict=True	,							SCREAMING_SNAKE_CASE_  :      Union[str, Any]=0.0	,							SCREAMING_SNAKE_CASE_  :      List[Any]=0.0	,							SCREAMING_SNAKE_CASE_  :      Any=0.1	,							SCREAMING_SNAKE_CASE_  :      Union[str, Any]="gelu"	,							SCREAMING_SNAKE_CASE_  :      int=False	,							SCREAMING_SNAKE_CASE_  :      List[str]=True	,							SCREAMING_SNAKE_CASE_  :      str=0.02	,							SCREAMING_SNAKE_CASE_  :      Optional[Any]=1e-5	,							SCREAMING_SNAKE_CASE_  :      int=True	,							SCREAMING_SNAKE_CASE_  :      Optional[int]=None	,							SCREAMING_SNAKE_CASE_  :      Optional[int]=True	,							SCREAMING_SNAKE_CASE_  :      Dict=1_0	,							SCREAMING_SNAKE_CASE_  :      Tuple=8	,							SCREAMING_SNAKE_CASE_  :      Optional[int]=["stage1", "stage2"]	,							SCREAMING_SNAKE_CASE_  :      Union[str, Any]=[1, 2]	,							)	->					Dict:
					lowercase_					  = parent
					lowercase_					  = batch_size
					lowercase_					  = image_size
					lowercase_					  = patch_size
					lowercase_					  = num_channels
					lowercase_					  = embed_dim
					lowercase_					  = depths
					lowercase_					  = num_heads
					lowercase_					  = window_size
					lowercase_					  = mlp_ratio
					lowercase_					  = qkv_bias
					lowercase_					  = hidden_dropout_prob
					lowercase_					  = attention_probs_dropout_prob
					lowercase_					  = drop_path_rate
					lowercase_					  = hidden_act
					lowercase_					  = use_absolute_embeddings
					lowercase_					  = patch_norm
					lowercase_					  = layer_norm_eps
					lowercase_					  = initializer_range
					lowercase_					  = is_training
					lowercase_					  = scope
					lowercase_					  = use_labels
					lowercase_					  = type_sequence_label_size
					lowercase_					  = encoder_stride
					lowercase_					  = out_features
					lowercase_					  = out_indices
	def 						_lowercase  (	self  :      List[str]	)	->					Any:
					lowercase_					  = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

					lowercase_					  = self.get_config()

					return config, pixel_values, labels
	def 						_lowercase  (	self  :      List[str]	)	->					Any:
					return SwinConfig(
					    image_size=self.image_size	,							patch_size=self.patch_size	,							num_channels=self.num_channels	,							embed_dim=self.embed_dim	,							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  :      Any	,							SCREAMING_SNAKE_CASE_  :      Any	,							SCREAMING_SNAKE_CASE_  :      int	,							SCREAMING_SNAKE_CASE_  :      int	)	->					Optional[Any]:
					lowercase_					  = SwinModel(config=SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()
					lowercase_					  = model(SCREAMING_SNAKE_CASE_	)

					lowercase_					  = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
					lowercase_					  = 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  :      Optional[int]	,							SCREAMING_SNAKE_CASE_  :      Optional[Any]	,							SCREAMING_SNAKE_CASE_  :      Any	,							SCREAMING_SNAKE_CASE_  :      Optional[Any]	)	->					Tuple:
					lowercase_					  = SwinBackbone(config=SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()
					lowercase_					  = model(SCREAMING_SNAKE_CASE_	)

					# verify hidden states
					self.parent.assertEqual(len(result.feature_maps	)	,							len(config.out_features	)	)
					self.parent.assertListEqual(list(result.feature_maps[0].shape	)	,							[self.batch_size, model.channels[0], 1_6, 1_6]	)

					# verify channels
					self.parent.assertEqual(len(model.channels	)	,							len(config.out_features	)	)

					# verify backbone works with out_features=None
					lowercase_					  = None
					lowercase_					  = SwinBackbone(config=SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()
					lowercase_					  = model(SCREAMING_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, model.channels[-1], 4, 4]	)

					# verify channels
					self.parent.assertEqual(len(model.channels	)	,							1	)
	def 						_lowercase  (	self  :      str	,							SCREAMING_SNAKE_CASE_  :      Optional[int]	,							SCREAMING_SNAKE_CASE_  :      Tuple	,							SCREAMING_SNAKE_CASE_  :      Tuple	)	->					Tuple:
					lowercase_					  = SwinForMaskedImageModeling(config=SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()
					lowercase_					  = model(SCREAMING_SNAKE_CASE_	)
					self.parent.assertEqual(
					    result.logits.shape	,							(self.batch_size, self.num_channels, self.image_size, self.image_size)	)

					# test greyscale images
					lowercase_					  = 1
					lowercase_					  = SwinForMaskedImageModeling(SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()

					lowercase_					  = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
					lowercase_					  = model(SCREAMING_SNAKE_CASE_	)
					self.parent.assertEqual(result.logits.shape	,							(self.batch_size, 1, self.image_size, self.image_size)	)
	def 						_lowercase  (	self  :      Any	,							SCREAMING_SNAKE_CASE_  :      str	,							SCREAMING_SNAKE_CASE_  :      Dict	,							SCREAMING_SNAKE_CASE_  :      List[str]	)	->					Union[str, Any]:
					lowercase_					  = self.type_sequence_label_size
					lowercase_					  = SwinForImageClassification(SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()
					lowercase_					  = model(SCREAMING_SNAKE_CASE_	,							labels=SCREAMING_SNAKE_CASE_	)
					self.parent.assertEqual(result.logits.shape	,							(self.batch_size, self.type_sequence_label_size)	)

					# test greyscale images
					lowercase_					  = 1
					lowercase_					  = SwinForImageClassification(SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()

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




	def 						_lowercase  (	self  :      List[str]	)	->					Any:
					lowercase_					  = self.prepare_config_and_inputs()
					(
					    (
					    lowercase_     
					)  ,     (
					    lowercase_     
					)  ,     (
					    lowercase_     
					)  ,          
					)					  = config_and_inputs
					lowercase_					  = {'''pixel_values''': pixel_values}
					return config, inputs_dict

@require_torch
class 			lowercase__(    UpperCAmelCase			,						UpperCAmelCase			,						unittest.TestCase							):



	"""simple docstring"""




	a      :Tuple   					=     (
	    (
	        SwinModel,
	        SwinBackbone,
	        SwinForImageClassification,
	        SwinForMaskedImageModeling,
	    )
	    if is_torch_available()
	    else ()
	)
	a      :Optional[Any]   					=     (
	    {'feature-extraction': SwinModel, 'image-classification': SwinForImageClassification}
	    if is_torch_available()
	    else {}
	)
	a      :Any   					=     True

	a      :str   					=     False
	a      :Optional[Any]   					=     False
	a      :Dict   					=     False
	def 						_lowercase  (	self  :      List[str]	)	->					str:
					lowercase_					  = SwinModelTester(self	)
					lowercase_					  = ConfigTester(self	,							config_class=SCREAMING_SNAKE_CASE_	,							embed_dim=3_7	)
	def 						_lowercase  (	self  :      Optional[int]	)	->					Optional[int]:
					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	)	->					List[Any]:
					return
	def 						_lowercase  (	self  :      List[Any]	)	->					Tuple:
					lowercase_					  = self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)
	@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''	)
	def 						_lowercase  (	self  :      Tuple	)	->					Union[str, Any]:
					pass
	def 						_lowercase  (	self  :      int	)	->					Dict:
					super().test_training_gradient_checkpointing()
	def 						_lowercase  (	self  :      List[Any]	)	->					Any:
					lowercase_					  = self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_	)
	def 						_lowercase  (	self  :      List[str]	)	->					List[str]:
					lowercase_					  = self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_	)
	def 						_lowercase  (	self  :      Any	)	->					Tuple:
					lowercase_					  = self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_	)
	@unittest.skip(reason='''Swin does not use inputs_embeds'''	)
	def 						_lowercase  (	self  :      Union[str, Any]	)	->					Tuple:
					pass
	@unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''	)
	def 						_lowercase  (	self  :      List[Any]	)	->					Optional[Any]:
					pass
	def 						_lowercase  (	self  :      Optional[int]	)	->					Union[str, Any]:
					lowercase_  ,     lowercase_					  = self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									lowercase_					  = model_class(SCREAMING_SNAKE_CASE_	)
									self.assertIsInstance(model.get_input_embeddings()	,							(nn.Module)	)
									lowercase_					  = model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_	,							nn.Linear	)	)
	def 						_lowercase  (	self  :      int	)	->					Optional[int]:
					lowercase_  ,     lowercase_					  = self.model_tester.prepare_config_and_inputs_for_common()

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

									lowercase_					  = ['''pixel_values''']
									self.assertListEqual(arg_names[:1]	,							SCREAMING_SNAKE_CASE_	)
	def 						_lowercase  (	self  :      Tuple	)	->					Optional[int]:
					lowercase_  ,     lowercase_					  = self.model_tester.prepare_config_and_inputs_for_common()
					lowercase_					  = True

					for model_class in self.all_model_classes:
									lowercase_					  = True
									lowercase_					  = False
									lowercase_					  = True
									lowercase_					  = model_class(SCREAMING_SNAKE_CASE_	)
									model.to(SCREAMING_SNAKE_CASE_	)
									model.eval()
									with torch.no_grad():
													lowercase_					  = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	)	)
									lowercase_					  = outputs.attentions
									lowercase_					  = len(self.model_tester.depths	)
									self.assertEqual(len(SCREAMING_SNAKE_CASE_	)	,							SCREAMING_SNAKE_CASE_	)

									# check that output_attentions also work using config
									del inputs_dict["output_attentions"]
									lowercase_					  = True
									lowercase_					  = config.window_size**2
									lowercase_					  = model_class(SCREAMING_SNAKE_CASE_	)
									model.to(SCREAMING_SNAKE_CASE_	)
									model.eval()
									with torch.no_grad():
													lowercase_					  = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	)	)
									lowercase_					  = outputs.attentions
									self.assertEqual(len(SCREAMING_SNAKE_CASE_	)	,							SCREAMING_SNAKE_CASE_	)

									self.assertListEqual(
									    list(attentions[0].shape[-3:]	)	,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared]	,							)
									lowercase_					  = len(SCREAMING_SNAKE_CASE_	)

									# Check attention is always last and order is fine
									lowercase_					  = True
									lowercase_					  = True
									lowercase_					  = model_class(SCREAMING_SNAKE_CASE_	)
									model.to(SCREAMING_SNAKE_CASE_	)
									model.eval()
									with torch.no_grad():
													lowercase_					  = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	)	)

									# also another +1 for reshaped_hidden_states
									lowercase_					  = 1 if model_class.__name__ == '''SwinBackbone''' else 2
									self.assertEqual(out_len + added_hidden_states	,							len(SCREAMING_SNAKE_CASE_	)	)

									lowercase_					  = outputs.attentions

									self.assertEqual(len(SCREAMING_SNAKE_CASE_	)	,							SCREAMING_SNAKE_CASE_	)

									self.assertListEqual(
									    list(self_attentions[0].shape[-3:]	)	,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared]	,							)
	def 						_lowercase  (	self  :      List[str]	,							SCREAMING_SNAKE_CASE_  :      Union[str, Any]	,							SCREAMING_SNAKE_CASE_  :      Tuple	,							SCREAMING_SNAKE_CASE_  :      Union[str, Any]	,							SCREAMING_SNAKE_CASE_  :      List[Any]	)	->					Union[str, Any]:
					lowercase_					  = model_class(SCREAMING_SNAKE_CASE_	)
					model.to(SCREAMING_SNAKE_CASE_	)
					model.eval()

					with torch.no_grad():
									lowercase_					  = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	)	)

					lowercase_					  = outputs.hidden_states

					lowercase_					  = getattr(
					    self.model_tester	,							'''expected_num_hidden_layers'''	,							len(self.model_tester.depths	) + 1	)
					self.assertEqual(len(SCREAMING_SNAKE_CASE_	)	,							SCREAMING_SNAKE_CASE_	)

					# Swin has a different seq_length
					lowercase_					  = (
					    config.patch_size
					    if isinstance(config.patch_size	,							collections.abc.Iterable	)
					    else (config.patch_size, config.patch_size)
					)

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

					if not model_class.__name__ == "SwinBackbone":
									lowercase_					  = outputs.reshaped_hidden_states
									self.assertEqual(len(SCREAMING_SNAKE_CASE_	)	,							SCREAMING_SNAKE_CASE_	)

									lowercase_  ,     lowercase_  ,     lowercase_  ,     lowercase_					  = reshaped_hidden_states[0].shape
									lowercase_					  = (
									    reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							height * width	).permute(0	,							2	,							1	)
									)
									self.assertListEqual(
									    list(reshaped_hidden_states.shape[-2:]	)	,							[num_patches, self.model_tester.embed_dim]	,							)
	def 						_lowercase  (	self  :      Dict	)	->					Optional[Any]:
					lowercase_  ,     lowercase_					  = self.model_tester.prepare_config_and_inputs_for_common()

					lowercase_					  = (
					    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:
									lowercase_					  = True
									self.check_hidden_states_output(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	)

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

									self.check_hidden_states_output(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	)
	def 						_lowercase  (	self  :      int	)	->					List[Any]:
					lowercase_  ,     lowercase_					  = self.model_tester.prepare_config_and_inputs_for_common()
					lowercase_					  = 3

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

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

					for model_class in self.all_model_classes:
									lowercase_					  = True
									self.check_hidden_states_output(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							(padded_height, padded_width)	)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									lowercase_					  = True
									self.check_hidden_states_output(SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							SCREAMING_SNAKE_CASE_	,							(padded_height, padded_width)	)
	@slow
	def 						_lowercase  (	self  :      Dict	)	->					Any:
					for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowercase_					  = SwinModel.from_pretrained(SCREAMING_SNAKE_CASE_	)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)




	def 						_lowercase  (	self  :      Any	)	->					Optional[Any]:
					lowercase_  ,     lowercase_					  = self.model_tester.prepare_config_and_inputs_for_common()

					lowercase_					  = _config_zero_init(SCREAMING_SNAKE_CASE_	)
					for model_class in self.all_model_classes:
									lowercase_					  = model_class(config=SCREAMING_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 			lowercase__(    unittest.TestCase							):



	"""simple docstring"""




	@cached_property
	def 						_lowercase  (	self  :      int	)	->					Tuple:
					return (
					    AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''	)
					    if is_vision_available()
					    else None
					)




	@slow
	def 						_lowercase  (	self  :      str	)	->					Union[str, Any]:
					lowercase_					  = SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''	).to(SCREAMING_SNAKE_CASE_	)
					lowercase_					  = self.default_image_processor

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

					# forward pass
					with torch.no_grad():
									lowercase_					  = model(**SCREAMING_SNAKE_CASE_	)

					# verify the logits
					lowercase_					  = torch.Size((1, 1_0_0_0)	)
					self.assertEqual(outputs.logits.shape	,							SCREAMING_SNAKE_CASE_	)
					lowercase_					  = torch.tensor([-0.09_48, -0.64_54, -0.09_21]	).to(SCREAMING_SNAKE_CASE_	)
					self.assertTrue(torch.allclose(outputs.logits[0, :3]	,							SCREAMING_SNAKE_CASE_	,							atol=1e-4	)	)

@require_torch
class 			lowercase__(    unittest.TestCase			,						UpperCAmelCase							):



	"""simple docstring"""




	a      :Dict   					=     (SwinBackbone,) if is_torch_available() else ()
	a      :Optional[int]   					=     SwinConfig
	def 						_lowercase  (	self  :      Any	)	->					Tuple:
					lowercase_					  = SwinModelTester(self	)






from __future__ import annotations

__a        = 'Alexander Joslin'




def     a						(							snake_case__: int ):


				'''simple docstring'''

				if number <= 0:
								lowercase_					  = F'''n must be greater than 0. Got n = {number}'''
								raise ValueError(snake_case__ )

				lowercase_					  = [number + 1] * (number + 1)

				# starting position
				lowercase_					  = 0
				for i in range(1						,       snake_case__ ):
								lowercase_					  = min(table[i + 1]						,       table[i] + 1 )
								# check if out of bounds
								if i * 2 <= number:
												lowercase_					  = min(table[i * 2]						,       table[i] + 1 )
								# check if out of bounds
								if i * 3 <= number:
												lowercase_					  = min(table[i * 3]						,       table[i] + 1 )
				return table[number]


if __name__ == "__main__":
						import doctest

						doctest.testmod()




