






"""simple docstring"""



import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import MaskFormerSwinBackbone
    from transformers.models.maskformer import MaskFormerSwinModel

class        a     :







    def __init__(			self							,		_lowerCamelCase							,		_lowerCamelCase=1_3							,		_lowerCamelCase=3_2							,		_lowerCamelCase=2							,		_lowerCamelCase=3							,		_lowerCamelCase=1_6							,		_lowerCamelCase=[1, 2, 1]							,		_lowerCamelCase=[2, 2, 4]							,		_lowerCamelCase=2							,		_lowerCamelCase=2.0							,		_lowerCamelCase=True							,		_lowerCamelCase=0.0							,		_lowerCamelCase=0.0							,		_lowerCamelCase=0.1							,		_lowerCamelCase="gelu"							,		_lowerCamelCase=False							,		_lowerCamelCase=True							,		_lowerCamelCase=0.0_2							,		_lowerCamelCase=1e-5							,		_lowerCamelCase=True							,		_lowerCamelCase=None							,		_lowerCamelCase=True							,		_lowerCamelCase=1_0							,		_lowerCamelCase=8							,		_lowerCamelCase=["stage1", "stage2", "stage3"]							,		_lowerCamelCase=[1, 2, 3]							,		):
      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 			UpperCamelCase_      (			self       ):
      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 			UpperCamelCase_      (			self       ):
      return MaskFormerSwinConfig(
          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 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
      lowercase							    =       MaskFormerSwinModel(config=_lowerCamelCase       )
      model.to(_lowerCamelCase       )
      model.eval()
      lowercase							    =       model(_lowerCamelCase       )

      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 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
      lowercase							    =       MaskFormerSwinBackbone(config=_lowerCamelCase       )
      model.to(_lowerCamelCase       )
      model.eval()
      lowercase							    =       model(_lowerCamelCase       )

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps       )							,		len(config.out_features       )       )
      self.parent.assertListEqual(list(result.feature_maps[0].shape       )							,		[1_3, 1_6, 1_6, 1_6]       )

      # verify channels
      self.parent.assertEqual(len(model.channels       )							,		len(config.out_features       )       )
      self.parent.assertListEqual(model.channels							,		[1_6, 3_2, 6_4]       )

      # verify ValueError
      with self.parent.assertRaises(_lowerCamelCase       ):
        lowercase							    =       ['stem']
        lowercase							    =       MaskFormerSwinBackbone(config=_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.prepare_config_and_inputs()
      lowercase    ,     lowercase    ,     lowercase							    =       config_and_inputs
      lowercase							    =       {'pixel_values': pixel_values}
      return config, inputs_dict


@require_torch
class        a     (   a_,				a_,				unittest.TestCase	):
    UpperCAmelCase_ :     Optional[int]	     =(
        (
            MaskFormerSwinModel,
            MaskFormerSwinBackbone,
        )
        if is_torch_available()
        else ()
    )
    UpperCAmelCase_ :     List[str]	     ={"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
    UpperCAmelCase_ :     Optional[Any]	     =False
    UpperCAmelCase_ :     Optional[Any]	     =False
    UpperCAmelCase_ :     Union[str, Any]	     =False
    UpperCAmelCase_ :     Any	     =False
    UpperCAmelCase_ :     Optional[Any]	     =False







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       MaskFormerSwinModelTester(self       )
      lowercase							    =       ConfigTester(self							,		config_class=_lowerCamelCase							,		embed_dim=3_7       )







    @require_torch_multi_gpu
    @unittest.skip(
        reason=(
            '`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'
            ' `nn.DataParallel`'
        )       )
    def 			UpperCamelCase_      (			self       ):
      pass







    def 			UpperCamelCase_      (			self       ):
      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 			UpperCamelCase_      (			self       ):
      return







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*_lowerCamelCase       )







    @unittest.skip('Swin does not use inputs_embeds'       )
    def 			UpperCamelCase_      (			self       ):
      pass







    @unittest.skip('Swin does not support feedforward chunking'       )
    def 			UpperCamelCase_      (			self       ):
      pass







    def 			UpperCamelCase_      (			self       ):
      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()

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







    def 			UpperCamelCase_      (			self       ):
      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase							    =       model_class(_lowerCamelCase       )
        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]							,		_lowerCamelCase       )







    @unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'       )
    def 			UpperCamelCase_      (			self       ):
      pass







    @unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'       )
    def 			UpperCamelCase_      (			self       ):
      pass







    def 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
      lowercase							    =       model_class(_lowerCamelCase       )
      model.to(_lowerCamelCase       )
      model.eval()

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

      lowercase							    =       outputs.hidden_states

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

      # 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]							,		)







    def 			UpperCamelCase_      (			self       ):
      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(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       )

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

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







    def 			UpperCamelCase_      (			self       ):
      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(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		(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(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		(padded_height, padded_width)       )







    @unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'       )
    def 			UpperCamelCase_      (			self       ):
      pass







    @unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'       )
    def 			UpperCamelCase_      (			self       ):
      pass







    @unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'       )
    def 			UpperCamelCase_      (			self       ):
      pass







    def 			UpperCamelCase_      (			self       ):
      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()

      def set_nan_tensor_to_zero(_lowerCamelCase       ):
        lowercase							    =       0
        return t

      def check_equivalence(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase={}       ):
        with torch.no_grad():
          lowercase							    =       model(**_lowerCamelCase							,		return_dict=_lowerCamelCase							,		**_lowerCamelCase       )
          lowercase							    =       model(**_lowerCamelCase							,		return_dict=_lowerCamelCase							,		**_lowerCamelCase       ).to_tuple()

          def recursive_check(_lowerCamelCase							,		_lowerCamelCase       ):
            if isinstance(_lowerCamelCase							,		(List, Tuple)       ):
              for tuple_iterable_value, dict_iterable_value in zip(_lowerCamelCase							,		_lowerCamelCase       ):
                recursive_check(_lowerCamelCase							,		_lowerCamelCase       )
            elif isinstance(_lowerCamelCase							,		_lowerCamelCase       ):
              for tuple_iterable_value, dict_iterable_value in zip(
                  tuple_object.values()							,		dict_object.values()       ):
                recursive_check(_lowerCamelCase							,		_lowerCamelCase       )
            elif tuple_object is None:
              return
            else:
              self.assertTrue(
                  torch.allclose(
                      set_nan_tensor_to_zero(_lowerCamelCase       )							,		set_nan_tensor_to_zero(_lowerCamelCase       )							,		atol=1e-5       )							,		msg=(
                      'Tuple and dict output are not equal. Difference:'
                      F' {torch.max(torch.abs(tuple_object - dict_object       )       )}. Tuple has `nan`:'
                      F' {torch.isnan(_lowerCamelCase       ).any()} and `inf`: {torch.isinf(_lowerCamelCase       )}. Dict has'
                      F' `nan`: {torch.isnan(_lowerCamelCase       ).any()} and `inf`: {torch.isinf(_lowerCamelCase       )}.'
                  )							,		)

          recursive_check(_lowerCamelCase							,		_lowerCamelCase       )

      for model_class in self.all_model_classes:
        lowercase							    =       model_class(_lowerCamelCase       )
        model.to(_lowerCamelCase       )
        model.eval()

        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )
        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )
        check_equivalence(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       )

        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase							,		return_labels=_lowerCamelCase       )
        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase							,		return_labels=_lowerCamelCase       )
        check_equivalence(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       )

        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )
        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )
        check_equivalence(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		{'output_hidden_states': True}       )

        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase							,		return_labels=_lowerCamelCase       )
        lowercase							    =       self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase							,		return_labels=_lowerCamelCase       )
        check_equivalence(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		{'output_hidden_states': True}       )


@require_torch
class        a     (   unittest.TestCase,				a_	):
    UpperCAmelCase_ :     str	     =(MaskFormerSwinBackbone,) if is_torch_available() else ()
    UpperCAmelCase_ :     str	     =MaskFormerSwinConfig







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       MaskFormerSwinModelTester(self       )







    def 			UpperCamelCase_      (			self       ):
      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()
      lowercase							    =       inputs_dict['pixel_values'].shape[0]

      for backbone_class in self.all_model_classes:
        lowercase							    =       backbone_class(_lowerCamelCase       )
        backbone.to(_lowerCamelCase       )
        backbone.eval()

        lowercase							    =       backbone(**_lowerCamelCase       )

        # Test default outputs and verify feature maps
        self.assertIsInstance(outputs.feature_maps							,		_lowerCamelCase       )
        self.assertTrue(len(outputs.feature_maps       ) == len(backbone.channels       )       )
        for feature_map, n_channels in zip(outputs.feature_maps							,		backbone.channels       ):
          self.assertTrue(feature_map.shape[:2]							,		(batch_size, n_channels)       )
        self.assertIsNone(outputs.hidden_states       )
        self.assertIsNone(outputs.attentions       )

        # Test output_hidden_states=True
        lowercase							    =       backbone(**_lowerCamelCase							,		output_hidden_states=_lowerCamelCase       )
        self.assertIsNotNone(outputs.hidden_states       )
        self.assertTrue(len(outputs.hidden_states       )							,		len(backbone.stage_names       )       )
        # We skip the stem layer
        for hidden_states, n_channels in zip(outputs.hidden_states[1:]							,		backbone.channels       ):
          for hidden_state in hidden_states:
            # Hidden states are in the format (batch_size, (height * width), n_channels)
            lowercase    ,     lowercase    ,     lowercase							    =       hidden_state.shape
            self.assertTrue((h_batch_size, h_n_channels)							,		(batch_size, n_channels)       )

            # Test output_attentions=True
        if self.has_attentions:
          lowercase							    =       backbone(**_lowerCamelCase							,		output_attentions=_lowerCamelCase       )
          self.assertIsNotNone(outputs.attentions       )










"""simple docstring"""



from argparse import ArgumentParser

from .env import EnvironmentCommand
def 						_SCREAMING_SNAKE_CASE (    ):





  '''simple docstring'''





  lowercase							    =       ArgumentParser('Diffusers CLI tool'		,					usage='diffusers-cli <command> [<args>]'    )
  lowercase							    =       parser.add_subparsers(help='diffusers-cli command helpers'    )

  # Register commands
  EnvironmentCommand.register_subcommand(__snake_case    )

  # Let's go
  lowercase							    =       parser.parse_args()

  if not hasattr(__snake_case		,					'func'    ):
    parser.print_help()
    exit(1    )

  # Run
  lowercase							    =       args.func(__snake_case    )
  service.run()


if __name__ == "__main__":
    main()


