code: 
  
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  from dataclasses import dataclass
  from enum import Enum
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  
  
  
  
  
  @dataclass
  class     UpperCAmelCase_		(      lowercase				):
  
  
  
        """simple docstring"""
        UpperCamelCase_       :      int     ={
            'sld_warmup_steps': 15,
            'sld_guidance_scale': 20,
            'sld_threshold': 0.0,
            'sld_momentum_scale': 0.0,
            'sld_mom_beta': 0.0,
        }
        UpperCamelCase_       :      str     ={
            'sld_warmup_steps': 10,
            'sld_guidance_scale': 1000,
            'sld_threshold': 0.01,
            'sld_momentum_scale': 0.3,
            'sld_mom_beta': 0.4,
        }
        UpperCamelCase_       :      Any     ={
            'sld_warmup_steps': 7,
            'sld_guidance_scale': 2000,
            'sld_threshold': 0.025,
            'sld_momentum_scale': 0.5,
            'sld_mom_beta': 0.7,
        }
        UpperCamelCase_       :      Dict     ={
            'sld_warmup_steps': 0,
            'sld_guidance_scale': 5000,
            'sld_threshold': 1.0,
            'sld_momentum_scale': 0.5,
            'sld_mom_beta': 0.7,
        }
  
  
  
  
  
  
  
  @dataclass
  class     UpperCAmelCase_		(      lowercase				):
  
  
  
        """simple docstring"""
        UpperCamelCase_       :      Union[List[PIL.Image.Image], np.ndarray]
        UpperCamelCase_       :      Optional[List[bool]]
        UpperCamelCase_       :      Optional[Union[List[PIL.Image.Image], np.ndarray]]
        UpperCamelCase_       :      Optional[str]
  
  
  if is_transformers_available() and is_torch_available():
   from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
   from .safety_checker import SafeStableDiffusionSafetyChecker
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  import inspect
  import unittest
  
  import numpy as np
  
  from transformers import SwinConfig
  from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
  from transformers.utils import cached_property, is_tf_available, is_vision_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
   import tensorflow as tf
  
   from transformers.models.swin.modeling_tf_swin import (
       TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFSwinForImageClassification,
       TFSwinForMaskedImageModeling,
       TFSwinModel,
   )
  
  
  if is_vision_available():
   from PIL import Image
  
   from transformers import AutoImageProcessor
  
  
  
  
  
  
  
  class     UpperCAmelCase_		:
  
  
  
        """simple docstring"""
        def __init__(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_=13					,       SCREAMING_SNAKE_CASE_=32					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=3					,       SCREAMING_SNAKE_CASE_=16					,       SCREAMING_SNAKE_CASE_=[1, 2, 1]					,       SCREAMING_SNAKE_CASE_=[2, 2, 4]					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=2.0					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=0.0					,       SCREAMING_SNAKE_CASE_=0.0					,       SCREAMING_SNAKE_CASE_=0.1					,       SCREAMING_SNAKE_CASE_="gelu"					,       SCREAMING_SNAKE_CASE_=False					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=0.02					,       SCREAMING_SNAKE_CASE_=1e-5					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=None					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=10					,       SCREAMING_SNAKE_CASE_=8					,       )       ->   None:
            UpperCamelCase :Optional[Any]										=     parent
            UpperCamelCase :Optional[Any]										=     batch_size
            UpperCamelCase :List[Any]										=     image_size
            UpperCamelCase :List[Any]										=     patch_size
            UpperCamelCase :List[Any]										=     num_channels
            UpperCamelCase :Optional[Any]										=     embed_dim
            UpperCamelCase :List[Any]										=     depths
            UpperCamelCase :List[Any]										=     num_heads
            UpperCamelCase :Tuple										=     window_size
            UpperCamelCase :Optional[int]										=     mlp_ratio
            UpperCamelCase :int										=     qkv_bias
            UpperCamelCase :str										=     hidden_dropout_prob
            UpperCamelCase :Dict										=     attention_probs_dropout_prob
            UpperCamelCase :Dict										=     drop_path_rate
            UpperCamelCase :Optional[Any]										=     hidden_act
            UpperCamelCase :int										=     use_absolute_embeddings
            UpperCamelCase :Any										=     patch_norm
            UpperCamelCase :str										=     layer_norm_eps
            UpperCamelCase :List[Any]										=     initializer_range
            UpperCamelCase :str										=     is_training
            UpperCamelCase :Union[str, Any]										=     scope
            UpperCamelCase :List[str]										=     use_labels
            UpperCamelCase :Union[str, Any]										=     type_sequence_label_size
            UpperCamelCase :int										=     encoder_stride
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase :Dict										=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
  
            UpperCamelCase :List[Any]										=     None
            if self.use_labels:
                UpperCamelCase :Tuple										=     ids_tensor([self.batch_size]					,       self.type_sequence_label_size				)
  
            UpperCamelCase :List[str]										=     self.get_config()
  
            return config, pixel_values, labels
        def 					UpperCAmelCase		(       self				)       ->   int:
            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					,       )
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   List[Any]:
            UpperCamelCase :int										=     TFSwinModel(config=SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase :str										=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
            UpperCamelCase :Union[str, Any]										=     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					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Any:
            UpperCamelCase :int										=     TFSwinForMaskedImageModeling(config=SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :List[str]										=     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
            UpperCamelCase :Optional[int]										=     1
            UpperCamelCase :int										=     TFSwinForMaskedImageModeling(SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase :str										=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
            UpperCamelCase :str										=     model(SCREAMING_SNAKE_CASE_				)
            self.parent.assertEqual(result.logits.shape					,       (self.batch_size, 1, self.image_size, self.image_size)				)
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   List[str]:
            UpperCamelCase :Optional[Any]										=     self.type_sequence_label_size
            UpperCamelCase :Optional[int]										=     TFSwinForImageClassification(SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Tuple										=     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
            UpperCamelCase :Union[str, Any]										=     1
            UpperCamelCase :Tuple										=     TFSwinForImageClassification(SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Any										=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
            UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_				)
            self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.type_sequence_label_size)				)
  
  
  
  
        def 					UpperCAmelCase		(       self				)       ->   int:
            UpperCamelCase :List[str]										=     self.prepare_config_and_inputs()
            UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Optional[Any]										=     config_and_inputs
            UpperCamelCase :Any										=     {'''pixel_values''': pixel_values}
            return config, inputs_dict
  
  
  
  
  
  
  
  @require_tf
  class     UpperCAmelCase_		(      lowercase,			lowercase,			unittest.TestCase				):
  
  
  
        """simple docstring"""
        UpperCamelCase_       :      int     =(
            (
                TFSwinModel,
                TFSwinForImageClassification,
                TFSwinForMaskedImageModeling,
            )
            if is_tf_available()
            else ()
        )
        UpperCamelCase_       :      Any     =(
            {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
            if is_tf_available()
            else {}
        )
  
        UpperCamelCase_       :      Optional[int]     =False
        UpperCamelCase_       :      int     =False
        UpperCamelCase_       :      Optional[int]     =False
        UpperCamelCase_       :      Any     =False
        def 					UpperCAmelCase		(       self				)       ->   Tuple:
            UpperCamelCase :str										=     TFSwinModelTester(self				)
            UpperCamelCase :str										=     ConfigTester(self					,       config_class=SCREAMING_SNAKE_CASE_					,       embed_dim=37				)
        def 					UpperCAmelCase		(       self				)       ->   Dict:
            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				)       ->   Union[str, Any]:
            return
        def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
            UpperCamelCase :Any										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase :Optional[int]										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
            UpperCamelCase :Any										=     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 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
            pass
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase							,     UpperCamelCase :int										=     self.model_tester.prepare_config_and_inputs_for_common()
  
            for model_class in self.all_model_classes:
                UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
                self.assertIsInstance(model.get_input_embeddings()					,       tf.keras.layers.Layer				)
                UpperCamelCase :Union[str, Any]										=     model.get_output_embeddings()
                self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_					,       tf.keras.layers.Dense				)				)
        def 					UpperCAmelCase		(       self				)       ->   str:
            UpperCamelCase							,     UpperCamelCase :str										=     self.model_tester.prepare_config_and_inputs_for_common()
  
            for model_class in self.all_model_classes:
                UpperCamelCase :Union[str, Any]										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Union[str, Any]										=     inspect.signature(model.call				)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                UpperCamelCase :Dict										=     [*signature.parameters.keys()]
  
                UpperCamelCase :Tuple										=     ['''pixel_values''']
                self.assertListEqual(arg_names[:1]					,       SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   List[Any]:
            UpperCamelCase							,     UpperCamelCase :Optional[int]										=     self.model_tester.prepare_config_and_inputs_for_common()
            UpperCamelCase :str										=     True
  
            for model_class in self.all_model_classes:
                UpperCamelCase :List[Any]										=     True
                UpperCamelCase :Optional[Any]										=     False
                UpperCamelCase :List[str]										=     True
                UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Union[str, Any]										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
                UpperCamelCase :List[Any]										=     outputs.attentions
                UpperCamelCase :int										=     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"]
                UpperCamelCase :Optional[Any]										=     True
                UpperCamelCase :List[Any]										=     config.window_size**2
                UpperCamelCase :Dict										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Dict										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
                UpperCamelCase :List[Any]										=     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]					,       )
                UpperCamelCase :List[Any]										=     len(SCREAMING_SNAKE_CASE_				)
  
                # Check attention is always last and order is fine
                UpperCamelCase :int										=     True
                UpperCamelCase :List[str]										=     True
                UpperCamelCase :List[str]										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Tuple										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
  
                if hasattr(self.model_tester					,       '''num_hidden_states_types'''				):
                    UpperCamelCase :Union[str, Any]										=     self.model_tester.num_hidden_states_types
                else:
                    # also another +1 for reshaped_hidden_states
                    UpperCamelCase :Optional[int]										=     2
                self.assertEqual(out_len + added_hidden_states					,       len(SCREAMING_SNAKE_CASE_				)				)
  
                UpperCamelCase :Optional[int]										=     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 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Dict:
            UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Any										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
            UpperCamelCase :Union[str, Any]										=     outputs.hidden_states
  
            UpperCamelCase :Any										=     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
            UpperCamelCase :str										=     to_atuple(config.patch_size				)
  
            UpperCamelCase :Optional[int]										=     (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]					,       )
  
            UpperCamelCase :str										=     outputs.reshaped_hidden_states
            self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Optional[int]										=     reshaped_hidden_states[0].shape
  
            UpperCamelCase :int										=     tf.reshape(reshaped_hidden_states[0]					,       (batch_size, num_channels, height * width)				)
            UpperCamelCase :Dict										=     tf.transpose(SCREAMING_SNAKE_CASE_					,       (0, 2, 1)				)
  
            self.assertListEqual(
                list(reshaped_hidden_states.shape[-2:]				)					,       [num_patches, self.model_tester.embed_dim]					,       )
        def 					UpperCAmelCase		(       self				)       ->   str:
            UpperCamelCase							,     UpperCamelCase :int										=     self.model_tester.prepare_config_and_inputs_for_common()
  
            UpperCamelCase :List[Any]										=     to_atuple(self.model_tester.image_size				)
  
            for model_class in self.all_model_classes:
                UpperCamelCase :List[Any]										=     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"]
                UpperCamelCase :List[str]										=     True
  
                self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
            UpperCamelCase							,     UpperCamelCase :List[Any]										=     self.model_tester.prepare_config_and_inputs_for_common()
            UpperCamelCase :List[Any]										=     3
  
            UpperCamelCase :Any										=     to_atuple(self.model_tester.image_size				)
            UpperCamelCase :List[Any]										=     to_atuple(config.patch_size				)
  
            UpperCamelCase :Dict										=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
            UpperCamelCase :List[str]										=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])
  
            for model_class in self.all_model_classes:
                UpperCamelCase :List[Any]										=     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"]
                UpperCamelCase :str										=     True
                self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       (padded_height, padded_width)				)
  
  
  
  
        @slow
        def 					UpperCAmelCase		(       self				)       ->   List[Any]:
            for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCamelCase :Dict										=     TFSwinModel.from_pretrained(SCREAMING_SNAKE_CASE_				)
                self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
  
  
  
  
  
  
  
  @require_vision
  @require_tf
  class     UpperCAmelCase_		(      unittest.TestCase				):
  
  
  
        """simple docstring"""
        @cached_property
        def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
            return (
                AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''				)
                if is_vision_available()
                else None
            )
  
  
  
  
        @slow
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase :Tuple										=     TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''				)
            UpperCamelCase :int										=     self.default_image_processor
  
            UpperCamelCase :Optional[int]										=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
            UpperCamelCase :List[str]										=     image_processor(images=SCREAMING_SNAKE_CASE_					,       return_tensors='''tf'''				)
  
            # forward pass
            UpperCamelCase :Optional[Any]										=     model(SCREAMING_SNAKE_CASE_				)
  
            # verify the logits
            UpperCamelCase :Tuple										=     tf.TensorShape((1, 1000)				)
            self.assertEqual(outputs.logits.shape					,       SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :List[Any]										=     tf.constant([-0.0948, -0.6454, -0.0921]				)
            self.assertTrue(np.allclose(outputs.logits[0, :3]					,       SCREAMING_SNAKE_CASE_					,       atol=1e-4				)				)
  
  
  
  
  
  