


import math







class     lowerCamelCase__		:






			"""simple docstring"""






			def __init__(							self ,  snake_case ,  snake_case ,  snake_case ,  snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    x
						UpperCamelCase__   =    y
						UpperCamelCase__   =    step_size
						UpperCamelCase__   =    function_to_optimize




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						return self.function(self.x ,  self.y       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.step_size
						return [
						    SearchProblem(snake_case ,  snake_case ,  snake_case ,  self.function       )
						    for x, y in (
						        (self.x - step_size, self.y - step_size),
						        (self.x - step_size, self.y),
						        (self.x - step_size, self.y + step_size),
						        (self.x, self.y - step_size),
						        (self.x, self.y + step_size),
						        (self.x + step_size, self.y - step_size),
						        (self.x + step_size, self.y),
						        (self.x + step_size, self.y + step_size),
						    )
						]




			def __hash__(							self       ):

						'''simple docstring'''


						return hash(str(self       )       )




			def __eq__(							self ,  snake_case       ):

						'''simple docstring'''


						if isinstance(snake_case ,  snake_case       ):
									return hash(str(self       )       ) == hash(str(snake_case       )       )
						return False







			def __str__(							self       ):

						'''simple docstring'''


						return F'''x: {self.x} y: {self.y}'''



def     UpperCamelCase_(			_A				:Any			,  _A				:bool = True			,  _A				:float = math.inf			,  _A				:float = -math.inf			,  _A				:float = math.inf			,  _A				:float = -math.inf			,  _A				:bool = False			,  _A				:int = 1_00_00			,  )->						SearchProblem:
			UpperCamelCase__   =    search_prob
			UpperCamelCase__   =    []  # list to store the current score at each iteration
			UpperCamelCase__   =    0
			UpperCamelCase__   =    False
			UpperCamelCase__   =    set()
			while not solution_found and iterations < max_iter:
						visited.add(_A					)
						iterations += 1
						UpperCamelCase__   =    current_state.score()
						scores.append(_A					)
						UpperCamelCase__   =    current_state.get_neighbors()
						UpperCamelCase__   =    -math.inf
						UpperCamelCase__   =    math.inf
						UpperCamelCase__   =    None  # to hold the next best neighbor
						for neighbor in neighbors:
									if neighbor in visited:
												continue  # do not want to visit the same state again
									if (
									    neighbor.x > max_x
									    or neighbor.x < min_x
									    or neighbor.y > max_y
									    or neighbor.y < min_y
									):
												continue  # neighbor outside our bounds
									UpperCamelCase__   =    neighbor.score() - current_score
									if find_max:  # finding max
												# going to direction with greatest ascent
												if change > max_change and change > 0:
															UpperCamelCase__   =    change
															UpperCamelCase__   =    neighbor
									else:  # finding min
												# to direction with greatest descent
												if change < min_change and change < 0:
															UpperCamelCase__   =    change
															UpperCamelCase__   =    neighbor
						if next_state is not None:
									# we found at least one neighbor which improved the current state
									UpperCamelCase__   =    next_state
						else:
									# since we have no neighbor that improves the solution we stop the search
									UpperCamelCase__   =    True

			if visualization:
						from matplotlib import pyplot as plt

						plt.plot(range(_A					)			,  _A					)
						plt.xlabel("Iterations"					)
						plt.ylabel("Function values"					)
						plt.show()

			return current_state


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						def     UpperCamelCase_(			_A				:Any			,  _A				:Union[str, Any]					)->						Dict:
									return (x**2) + (y**2)

						# starting the problem with initial coordinates (3, 4)
						__UpperCamelCase      						=    SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
						__UpperCamelCase      						=    hill_climbing(prob, find_max=False)
						print(
						    'The minimum score for f(x, y) = x^2 + y^2 found via hill climbing: '
						    f'''{local_min.score()}'''
						)

						# starting the problem with initial coordinates (12, 47)
						__UpperCamelCase      						=    SearchProblem(x=1_2, y=4_7, step_size=1, function_to_optimize=test_fa)
						__UpperCamelCase      						=    hill_climbing(
						    prob, find_max=False, max_x=1_0_0, min_x=5, max_y=5_0, min_y=-5, visualization=True
						)
						print(
						    'The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 '
						    f'''and 50 > y > - 5 found via hill climbing: {local_min.score()}'''
						)
						def     UpperCamelCase_(			_A				:Tuple			,  _A				:str					)->						Tuple:
									return (3 * x**2) - (6 * y)

						__UpperCamelCase      						=    SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
						__UpperCamelCase      						=    hill_climbing(prob, find_max=True)







						print(
						    'The maximum score for f(x, y) = x^2 + y^2 found via hill climbing: '
						    f'''{local_min.score()}'''
						)






import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

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 SwinaSRForImageSuperResolution, SwinaSRModel
						from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
						from PIL import Image

						from transformers import SwinaSRImageProcessor







class     lowerCamelCase__		:






			"""simple docstring"""






			def __init__(							self ,  snake_case ,  snake_case=13 ,  snake_case=32 ,  snake_case=1 ,  snake_case=3 ,  snake_case=16 ,  snake_case=[1, 2, 1] ,  snake_case=[2, 2, 4] ,  snake_case=2 ,  snake_case=2.0 ,  snake_case=True ,  snake_case=0.0 ,  snake_case=0.0 ,  snake_case=0.1 ,  snake_case="gelu" ,  snake_case=False ,  snake_case=True ,  snake_case=0.02 ,  snake_case=1E-5 ,  snake_case=True ,  snake_case=None ,  snake_case=False ,  snake_case=2 ,  ):

						'''simple docstring'''


						UpperCamelCase__   =    parent
						UpperCamelCase__   =    batch_size
						UpperCamelCase__   =    image_size
						UpperCamelCase__   =    patch_size
						UpperCamelCase__   =    num_channels
						UpperCamelCase__   =    embed_dim
						UpperCamelCase__   =    depths
						UpperCamelCase__   =    num_heads
						UpperCamelCase__   =    window_size
						UpperCamelCase__   =    mlp_ratio
						UpperCamelCase__   =    qkv_bias
						UpperCamelCase__   =    hidden_dropout_prob
						UpperCamelCase__   =    attention_probs_dropout_prob
						UpperCamelCase__   =    drop_path_rate
						UpperCamelCase__   =    hidden_act
						UpperCamelCase__   =    use_absolute_embeddings
						UpperCamelCase__   =    patch_norm
						UpperCamelCase__   =    layer_norm_eps
						UpperCamelCase__   =    initializer_range
						UpperCamelCase__   =    is_training
						UpperCamelCase__   =    scope
						UpperCamelCase__   =    use_labels
						UpperCamelCase__   =    upscale

						# here we set some attributes to make tests pass
						UpperCamelCase__   =    len(snake_case       )
						UpperCamelCase__   =    embed_dim
						UpperCamelCase__   =    (image_size // patch_size) ** 2




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

						UpperCamelCase__   =    self.get_config()

						return config, pixel_values, labels




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						return SwinaSRConfig(
						    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 ,  upscale=self.upscale ,  )




			def 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    SwinaSRModel(config=snake_case       )
						model.to(snake_case       )
						model.eval()
						UpperCamelCase__   =    model(snake_case       )

						self.parent.assertEqual(
						    result.last_hidden_state.shape ,  (self.batch_size, self.embed_dim, self.image_size, self.image_size)       )




			def 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    SwinaSRForImageSuperResolution(snake_case       )
						model.to(snake_case       )
						model.eval()
						UpperCamelCase__   =    model(snake_case       )

						UpperCamelCase__   =    self.image_size * self.upscale
						self.parent.assertEqual(
						    result.reconstruction.shape ,  (self.batch_size, self.num_channels, expected_image_size, expected_image_size)       )







			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.prepare_config_and_inputs()
						UpperCamelCase__, UpperCamelCase__, UpperCamelCase__   =    config_and_inputs
						UpperCamelCase__   =    {"pixel_values": pixel_values}
						return config, inputs_dict







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






			"""simple docstring"""






			_UpperCamelCase						:   Dict					=						(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
			_UpperCamelCase						:   Optional[int]					=						{'feature-extraction': SwinaSRModel} if is_torch_available() else {}

			_UpperCamelCase						:   Tuple					=						False
			_UpperCamelCase						:   str					=						False
			_UpperCamelCase						:   Optional[Any]					=						False
			_UpperCamelCase						:   Any					=						False
			_UpperCamelCase						:   List[str]					=						False




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    SwinaSRModelTester(self       )
						UpperCamelCase__   =    ConfigTester(self ,  config_class=snake_case ,  embed_dim=37       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						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       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_super_resolution(*snake_case       )




			@unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."       )
			def 			snake_case__			(							self       ):

						'''simple docstring'''


						pass




			@unittest.skip(reason="Swin2SR does not use inputs_embeds"       )
			def 			snake_case__			(							self       ):

						'''simple docstring'''


						pass




			@unittest.skip(reason="Swin2SR does not support training yet"       )
			def 			snake_case__			(							self       ):

						'''simple docstring'''


						pass




			@unittest.skip(reason="Swin2SR does not support training yet"       )
			def 			snake_case__			(							self       ):

						'''simple docstring'''


						pass




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__, UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									UpperCamelCase__   =    model_class(snake_case       )
									self.assertIsInstance(model.get_input_embeddings() ,  (nn.Module)       )
									UpperCamelCase__   =    model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(snake_case ,  nn.Linear       )       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__, UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs_for_common()

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

									UpperCamelCase__   =    ["pixel_values"]
									self.assertListEqual(arg_names[:1] ,  snake_case       )




			@slow
			def 			snake_case__			(							self       ):

						'''simple docstring'''


						for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCamelCase__   =    SwinaSRModel.from_pretrained(snake_case       )
									self.assertIsNotNone(snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__, UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs_for_common()

						UpperCamelCase__   =    _config_zero_init(snake_case       )
						for model_class in self.all_model_classes:
									UpperCamelCase__   =    model_class(config=snake_case       )
									for name, param in model.named_parameters():
												if "logit_scale" in name:
															continue
												if 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''' ,  )







			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__, UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs_for_common()
						UpperCamelCase__   =    True

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

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

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

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

									self.assertEqual(out_len + 1 ,  len(snake_case       )       )

									UpperCamelCase__   =    outputs.attentions

									self.assertEqual(len(snake_case       ) ,  snake_case       )

									self.assertListEqual(
									    list(self_attentions[0].shape[-3:]       ) ,  [self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,  )







@require_vision
@require_torch
@slow
class     lowerCamelCase__		(							unittest.TestCase ):






			"""simple docstring"""






			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    SwinaSRImageProcessor()
						UpperCamelCase__   =    SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64"       ).to(snake_case       )

						UpperCamelCase__   =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
						UpperCamelCase__   =    processor(images=snake_case ,  return_tensors="pt"       ).to(snake_case       )

						# forward pass
						with torch.no_grad():
									UpperCamelCase__   =    model(**snake_case       )

						# verify the logits
						UpperCamelCase__   =    torch.Size([1, 3, 976, 1296]       )
						self.assertEqual(outputs.reconstruction.shape ,  snake_case       )
						UpperCamelCase__   =    torch.tensor(
						    [[0.5458, 0.5546, 0.5638], [0.5526, 0.5565, 0.5651], [0.5396, 0.5426, 0.5621]]       ).to(snake_case       )
						self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3] ,  snake_case ,  atol=1E-4       )       )


