





"""simple docstring"""





import collections
import inspect
import unittest

from transformers import DinatConfig
from transformers.testing_utils import require_natten, 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 DinatBackbone, DinatForImageClassification, DinatModel
    from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor





class 			snake_case		:

      def __init__(			self   :List[Any]						,							_lowerCamelCase   :Tuple						,							_lowerCamelCase   :Any=1_3						,							_lowerCamelCase   :str=6_4						,							_lowerCamelCase   :int=4						,							_lowerCamelCase   :List[str]=3						,							_lowerCamelCase   :Tuple=1_6						,							_lowerCamelCase   :Optional[int]=[1, 2, 1]						,							_lowerCamelCase   :Optional[Any]=[2, 4, 8]						,							_lowerCamelCase   :Tuple=3						,							_lowerCamelCase   :Tuple=[[3], [1, 2], [1]]						,							_lowerCamelCase   :List[Any]=2.0						,							_lowerCamelCase   :List[Any]=True						,							_lowerCamelCase   :int=0.0						,							_lowerCamelCase   :Any=0.0						,							_lowerCamelCase   :Union[str, Any]=0.1						,							_lowerCamelCase   :Optional[Any]="gelu"						,							_lowerCamelCase   :Tuple=True						,							_lowerCamelCase   :Any=0.0_2						,							_lowerCamelCase   :Optional[Any]=1e-5						,							_lowerCamelCase   :List[Any]=True						,							_lowerCamelCase   :int=None						,							_lowerCamelCase   :int=True						,							_lowerCamelCase   :str=1_0						,							_lowerCamelCase   :Union[str, Any]=["stage1", "stage2"]						,							_lowerCamelCase   :Union[str, Any]=[1, 2]						,							):
       __SCREAMING_SNAKE_CASE :			List[str]												=       parent
       __SCREAMING_SNAKE_CASE :			Any												=       batch_size
       __SCREAMING_SNAKE_CASE :			Dict												=       image_size
       __SCREAMING_SNAKE_CASE :			str												=       patch_size
       __SCREAMING_SNAKE_CASE :			Tuple												=       num_channels
       __SCREAMING_SNAKE_CASE :			Any												=       embed_dim
       __SCREAMING_SNAKE_CASE :			Tuple												=       depths
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       num_heads
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       kernel_size
       __SCREAMING_SNAKE_CASE :			Tuple												=       dilations
       __SCREAMING_SNAKE_CASE :			Tuple												=       mlp_ratio
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       qkv_bias
       __SCREAMING_SNAKE_CASE :			List[Any]												=       hidden_dropout_prob
       __SCREAMING_SNAKE_CASE :			str												=       attention_probs_dropout_prob
       __SCREAMING_SNAKE_CASE :			Tuple												=       drop_path_rate
       __SCREAMING_SNAKE_CASE :			Tuple												=       hidden_act
       __SCREAMING_SNAKE_CASE :			List[Any]												=       patch_norm
       __SCREAMING_SNAKE_CASE :			Dict												=       layer_norm_eps
       __SCREAMING_SNAKE_CASE :			str												=       initializer_range
       __SCREAMING_SNAKE_CASE :			Any												=       is_training
       __SCREAMING_SNAKE_CASE :			List[Any]												=       scope
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       use_labels
       __SCREAMING_SNAKE_CASE :			int												=       num_labels
       __SCREAMING_SNAKE_CASE :			Any												=       out_features
       __SCREAMING_SNAKE_CASE :			Dict												=       out_indices

      def 						SCREAMING_SNAKE_CASE_			(			self   :Dict						):
       __SCREAMING_SNAKE_CASE :			Tuple												=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

       __SCREAMING_SNAKE_CASE :			Tuple												=       None
       if self.use_labels:
        __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       ids_tensor([self.batch_size]						,							self.num_labels						)

       __SCREAMING_SNAKE_CASE :			int												=       self.get_config()

       return config, pixel_values, labels

      def 						SCREAMING_SNAKE_CASE_			(			self   :int						):
       return DinatConfig(
           num_labels=self.num_labels						,							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						,							kernel_size=self.kernel_size						,							dilations=self.dilations						,							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						,							patch_norm=self.patch_norm						,							layer_norm_eps=self.layer_norm_eps						,							initializer_range=self.initializer_range						,							out_features=self.out_features						,							out_indices=self.out_indices						,							)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Dict						,							_lowerCamelCase   :Tuple						,							_lowerCamelCase   :Optional[Any]						,							_lowerCamelCase   :Union[str, Any]						):
       __SCREAMING_SNAKE_CASE :			Any												=       DinatModel(config=_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			Dict												=       model(_lowerCamelCase						)

       __SCREAMING_SNAKE_CASE :			str												=       (config.image_size // config.patch_size) // (2 ** (len(config.depths						) - 1))
       __SCREAMING_SNAKE_CASE :			List[str]												=       int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

       self.parent.assertEqual(
           result.last_hidden_state.shape						,							(self.batch_size, expected_height, expected_width, expected_dim)						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Dict						,							_lowerCamelCase   :Optional[int]						,							_lowerCamelCase   :List[str]						,							_lowerCamelCase   :Optional[Any]						):
       __SCREAMING_SNAKE_CASE :			Any												=       DinatForImageClassification(_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       model(_lowerCamelCase						,							labels=_lowerCamelCase						)
       self.parent.assertEqual(result.logits.shape						,							(self.batch_size, self.num_labels)						)

       # test greyscale images
       __SCREAMING_SNAKE_CASE :			List[str]												=       1
       __SCREAMING_SNAKE_CASE :			int												=       DinatForImageClassification(_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()

       __SCREAMING_SNAKE_CASE :			Optional[int]												=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
       __SCREAMING_SNAKE_CASE :			int												=       model(_lowerCamelCase						)
       self.parent.assertEqual(result.logits.shape						,							(self.batch_size, self.num_labels)						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Tuple						,							_lowerCamelCase   :Optional[int]						,							_lowerCamelCase   :List[str]						,							_lowerCamelCase   :Dict						):
       __SCREAMING_SNAKE_CASE :			Any												=       DinatBackbone(config=_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			Dict												=       model(_lowerCamelCase						)

       # 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
       __SCREAMING_SNAKE_CASE :			Dict												=       None
       __SCREAMING_SNAKE_CASE :			Dict												=       DinatBackbone(config=_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			str												=       model(_lowerCamelCase						)

       # 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 						SCREAMING_SNAKE_CASE_			(			self   :Tuple						):
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       self.prepare_config_and_inputs()
       __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			List[str]												=       config_and_inputs
       __SCREAMING_SNAKE_CASE :			List[str]												=       {'''pixel_values''': pixel_values}
       return config, inputs_dict







@require_natten
@require_torch
class 			snake_case		(   __UpperCAmelCase ,     __UpperCAmelCase ,     unittest.TestCase   ):
      lowerCamelCase__						= (
          (
              DinatModel,
              DinatForImageClassification,
              DinatBackbone,
          )
          if is_torch_available()
          else ()
      )
      lowerCamelCase__						= (
          {'''feature-extraction''': DinatModel, '''image-classification''': DinatForImageClassification}
          if is_torch_available()
          else {}
      )
      lowerCamelCase__						= False

      lowerCamelCase__						= False
      lowerCamelCase__						= False
      lowerCamelCase__						= False
      lowerCamelCase__						= False

      def 						SCREAMING_SNAKE_CASE_			(			self   :int						):
       __SCREAMING_SNAKE_CASE :			str												=       DinatModelTester(self						)
       __SCREAMING_SNAKE_CASE :			str												=       ConfigTester(self						,							config_class=_lowerCamelCase						,							embed_dim=3_7						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Tuple						):
       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 						SCREAMING_SNAKE_CASE_			(			self   :List[Any]						):
       return

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[Any]						):
       __SCREAMING_SNAKE_CASE :			str												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :str						):
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[str]						):
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*_lowerCamelCase						)

      @unittest.skip(reason='''Dinat does not use inputs_embeds'''						)
      def 						SCREAMING_SNAKE_CASE_			(			self   :Any						):
       pass

      @unittest.skip(reason='''Dinat does not use feedforward chunking'''						)
      def 						SCREAMING_SNAKE_CASE_			(			self   :int						):
       pass

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[Any]						):
       __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			str												=       self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       model_class(_lowerCamelCase						)
        self.assertIsInstance(model.get_input_embeddings()						,							(nn.Module)						)
        __SCREAMING_SNAKE_CASE :			Optional[Any]												=       model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(_lowerCamelCase						,							nn.Linear						)						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Tuple						):
       __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			Optional[int]												=       self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        __SCREAMING_SNAKE_CASE :			List[Any]												=       model_class(_lowerCamelCase						)
        __SCREAMING_SNAKE_CASE :			Optional[int]												=       inspect.signature(model.forward						)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        __SCREAMING_SNAKE_CASE :			Dict												=       [*signature.parameters.keys()]

        __SCREAMING_SNAKE_CASE :			Dict												=       ['''pixel_values''']
        self.assertListEqual(arg_names[:1]						,							_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[Any]						):
       self.skipTest('''Dinat\'s attention operation is handled entirely by NATTEN.'''						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Union[str, Any]						,							_lowerCamelCase   :Union[str, Any]						,							_lowerCamelCase   :Any						,							_lowerCamelCase   :Union[str, Any]						,							_lowerCamelCase   :Any						):
       __SCREAMING_SNAKE_CASE :			int												=       model_class(_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()

       with torch.no_grad():
        __SCREAMING_SNAKE_CASE :			Any												=       model(**self._prepare_for_class(_lowerCamelCase						,							_lowerCamelCase						)						)

       __SCREAMING_SNAKE_CASE :			Any												=       outputs.hidden_states

       __SCREAMING_SNAKE_CASE :			str												=       getattr(
           self.model_tester						,							'''expected_num_hidden_layers'''						,							len(self.model_tester.depths						) + 1						)
       self.assertEqual(len(_lowerCamelCase						)						,							_lowerCamelCase						)

       # Dinat has a different seq_length
       __SCREAMING_SNAKE_CASE :			List[str]												=       (
           config.patch_size
           if isinstance(config.patch_size						,							collections.abc.Iterable						)
           else (config.patch_size, config.patch_size)
       )

       __SCREAMING_SNAKE_CASE :			int												=       image_size[0] // patch_size[0]
       __SCREAMING_SNAKE_CASE :			Any												=       image_size[1] // patch_size[1]

       self.assertListEqual(
           list(hidden_states[0].shape[-3:]						)						,							[height, width, self.model_tester.embed_dim]						,							)

       if model_class.__name__ != "DinatBackbone":
        __SCREAMING_SNAKE_CASE :			Any												=       outputs.reshaped_hidden_states
        self.assertEqual(len(_lowerCamelCase						)						,							_lowerCamelCase						)

        __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			Optional[int]												=       reshaped_hidden_states[0].shape
        __SCREAMING_SNAKE_CASE :			List[str]												=       (
            reshaped_hidden_states[0].view(_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						).permute(0						,							2						,							3						,							1						)
        )
        self.assertListEqual(
            list(reshaped_hidden_states.shape[-3:]						)						,							[height, width, self.model_tester.embed_dim]						,							)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[int]						):
       __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			List[str]												=       self.model_tester.prepare_config_and_inputs_for_common()

       __SCREAMING_SNAKE_CASE :			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:
        __SCREAMING_SNAKE_CASE :			List[str]												=       True
        self.check_hidden_states_output(_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        __SCREAMING_SNAKE_CASE :			Tuple												=       True

        self.check_hidden_states_output(_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						)

      @slow
      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[int]						):
       for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __SCREAMING_SNAKE_CASE :			Optional[Any]												=       DinatModel.from_pretrained(_lowerCamelCase						)
        self.assertIsNotNone(_lowerCamelCase						)



      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[Any]						):
       __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			List[str]												=       self.model_tester.prepare_config_and_inputs_for_common()

       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       _config_zero_init(_lowerCamelCase						)
       for model_class in self.all_model_classes:
        __SCREAMING_SNAKE_CASE :			List[Any]												=       model_class(config=_lowerCamelCase						)
        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_natten
@require_vision
@require_torch
class 			snake_case		(   unittest.TestCase   ):

      @cached_property
      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[int]						):
       return AutoImageProcessor.from_pretrained('''shi-labs/dinat-mini-in1k-224'''						) if is_vision_available() else None



      @slow
      def 						SCREAMING_SNAKE_CASE_			(			self   :List[str]						):
       __SCREAMING_SNAKE_CASE :			Dict												=       DinatForImageClassification.from_pretrained('''shi-labs/dinat-mini-in1k-224'''						).to(_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			int												=       self.default_image_processor

       __SCREAMING_SNAKE_CASE :			Optional[int]												=       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
       __SCREAMING_SNAKE_CASE :			List[str]												=       image_processor(images=_lowerCamelCase						,							return_tensors='''pt'''						).to(_lowerCamelCase						)

       # forward pass
       with torch.no_grad():
        __SCREAMING_SNAKE_CASE :			Tuple												=       model(**_lowerCamelCase						)

       # verify the logits
       __SCREAMING_SNAKE_CASE :			str												=       torch.Size((1, 1_0_0_0)						)
       self.assertEqual(outputs.logits.shape						,							_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			Dict												=       torch.tensor([-0.1_5_4_5, -0.7_6_6_7, 0.4_6_4_2]						).to(_lowerCamelCase						)
       self.assertTrue(torch.allclose(outputs.logits[0, :3]						,							_lowerCamelCase						,							atol=1e-4						)						)







@require_torch
@require_natten
class 			snake_case		(   unittest.TestCase ,     __UpperCAmelCase   ):
      lowerCamelCase__						= (DinatBackbone,) if is_torch_available() else ()
      lowerCamelCase__						= DinatConfig

      def 						SCREAMING_SNAKE_CASE_			(			self   :int						):
       __SCREAMING_SNAKE_CASE :			int												=       DinatModelTester(self						)


from __future__ import annotations

from PIL import Image

# Define the first generation of cells
# fmt: off
__SCREAMING_SNAKE_CASE						:    Optional[int]     = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
def 					snake_case						(__lowercase						)       ->       list[int]:

						'''simple docstring'''



						return [int(__lowercase						) for c in F"""{ruleset:08}"""[:8]]
def 					snake_case						(__lowercase					,			__lowercase					,			__lowercase						)       ->       list[int]:

						'''simple docstring'''



						_snake_case						:     Any				=    len(cells[0]						)  # 31
						_snake_case						:     str				=    []
						for i in range(__lowercase						):
												# Get the neighbors of each cell
												# Handle neighbours outside bounds by using 0 as their value
												_snake_case						:     Any				=    0 if i == 0 else cells[time][i - 1]
												_snake_case						:     List[str]				=    0 if i == population - 1 else cells[time][i + 1]
												# Define a new cell and add it to the new generation
												_snake_case						:     str				=    7 - int(F"""{left_neighbor}{cells[time][i]}{right_neighbor}"""					,			2						)
												next_generation.append(rule[situation]						)
						return next_generation
def 					snake_case						(__lowercase						)       ->       Image.Image:

						'''simple docstring'''



						_snake_case						:     str				=    Image.new("RGB"					,			(len(cells[0]						), len(__lowercase						))						)
						_snake_case						:     int				=    img.load()
						# Generates image
						for w in range(img.width						):
												for h in range(img.height						):
																		_snake_case						:     List[Any]				=    255 - int(255 * cells[h][w]						)
																		_snake_case						:     Union[str, Any]				=    (color, color, color)
						return img


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE						:    Any     = bin(int(input('Rule:\n').strip()))[2:]
				__SCREAMING_SNAKE_CASE						:    Tuple     = format_ruleset(int(rule_num))
				for time in range(1_6):
								CELLS.append(new_generation(CELLS, rule, time))
				__SCREAMING_SNAKE_CASE						:    List[Any]     = generate_image(CELLS)
				# Uncomment to save the image
				# img.save(f"rule_{rule_num}.png")
				img.show()