
'''simple docstring'''







import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
					import onnxruntime as ort


class 						__UpperCAmelCase      (					_lowerCamelCase						,   unittest.TestCase						):
							__lowercase      		=       """hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"""


							def  lowerCamelCase				(       self    ,   lowerCAmelCase_=0  ):





								"""simple docstring"""






								_snake_case   						=		floats_tensor((1, 3, 1_28, 1_28)    ,   rng=random.Random(lowerCAmelCase_  )  )
								_snake_case   						=		np.random.RandomState(lowerCAmelCase_  )
								_snake_case   						=		{
								    'prompt': 'A painting of a squirrel eating a burger',
								    'image': image,
								    'generator': generator,
								    'num_inference_steps': 3,
								    'strength': 0.75,
								    'guidance_scale': 7.5,
								    'output_type': 'numpy',
								}
								return inputs


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		self.get_dummy_inputs()
								_snake_case   						=		pipe(**lowerCAmelCase_  ).images
								_snake_case   						=		image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		np.array([0.69643, 0.58484, 0.50314, 0.58760, 0.55368, 0.59643, 0.51529, 0.41217, 0.49087]  )
								assert np.abs(image_slice - expected_slice  ).max() < 1E-1


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		PNDMScheduler.from_config(pipe.scheduler.config    ,   skip_prk_steps=lowerCAmelCase_  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		self.get_dummy_inputs()
								_snake_case   						=		pipe(**lowerCAmelCase_  ).images
								_snake_case   						=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		np.array([0.61737, 0.54642, 0.53183, 0.54465, 0.52742, 0.60525, 0.49969, 0.40655, 0.48154]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-1


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		LMSDiscreteScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								# warmup pass to apply optimizations
								_snake_case   						=		pipe(**self.get_dummy_inputs()  )

								_snake_case   						=		self.get_dummy_inputs()
								_snake_case   						=		pipe(**lowerCAmelCase_  ).images
								_snake_case   						=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		np.array([0.52761, 0.59977, 0.49033, 0.49619, 0.54282, 0.50311, 0.47600, 0.40918, 0.45203]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-1


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		EulerDiscreteScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		self.get_dummy_inputs()
								_snake_case   						=		pipe(**lowerCAmelCase_  ).images
								_snake_case   						=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		np.array([0.52911, 0.60004, 0.49229, 0.49805, 0.54502, 0.50680, 0.47777, 0.41028, 0.45304]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-1


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		self.get_dummy_inputs()
								_snake_case   						=		pipe(**lowerCAmelCase_  ).images
								_snake_case   						=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		np.array([0.52911, 0.60004, 0.49229, 0.49805, 0.54502, 0.50680, 0.47777, 0.41028, 0.45304]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-1




							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint    ,   provider='CPUExecutionProvider'  )
								_snake_case   						=		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config  )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		self.get_dummy_inputs()
								_snake_case   						=		pipe(**lowerCAmelCase_  ).images
								_snake_case   						=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 1_28, 1_28, 3)
								_snake_case   						=		np.array([0.65331, 0.58277, 0.48204, 0.56059, 0.53665, 0.56235, 0.50969, 0.40009, 0.46552]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-1


@nightly
@require_onnxruntime
@require_torch_gpu
class 						__UpperCAmelCase      (					unittest.TestCase						):


							@property
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								return (
								    "CUDAExecutionProvider",
								    {
								        "gpu_mem_limit": "15000000000",  # 15GB
								        "arena_extend_strategy": "kSameAsRequested",
								    },
								)


							@property
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		ort.SessionOptions()
								_snake_case   						=		False
								return options


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		load_image(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
								    '/img2img/sketch-mountains-input.jpg'  )
								_snake_case   						=		init_image.resize((7_68, 5_12)  )
								# using the PNDM scheduler by default
								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(
								    'CompVis/stable-diffusion-v1-4'    ,   revision='onnx'    ,   safety_checker=lowerCAmelCase_    ,   feature_extractor=lowerCAmelCase_    ,   provider=self.gpu_provider    ,   sess_options=self.gpu_options    ,   )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		'A fantasy landscape, trending on artstation'

								_snake_case   						=		np.random.RandomState(0  )
								_snake_case   						=		pipe(
								    prompt=lowerCAmelCase_    ,   image=lowerCAmelCase_    ,   strength=0.75    ,   guidance_scale=7.5    ,   num_inference_steps=10    ,   generator=lowerCAmelCase_    ,   output_type='np'    ,   )
								_snake_case   						=		output.images
								_snake_case   						=		images[0, 2_55:2_58, 3_83:3_86, -1]

								assert images.shape == (1, 5_12, 7_68, 3)
								_snake_case   						=		np.array([0.4909, 0.5059, 0.5372, 0.4623, 0.4876, 0.5049, 0.4820, 0.4956, 0.5019]  )
								# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 2E-2




							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		load_image(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
								    '/img2img/sketch-mountains-input.jpg'  )
								_snake_case   						=		init_image.resize((7_68, 5_12)  )
								_snake_case   						=		LMSDiscreteScheduler.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'    ,   subfolder='scheduler'    ,   revision='onnx'  )
								_snake_case   						=		OnnxStableDiffusionImgaImgPipeline.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'    ,   revision='onnx'    ,   scheduler=lowerCAmelCase_    ,   safety_checker=lowerCAmelCase_    ,   feature_extractor=lowerCAmelCase_    ,   provider=self.gpu_provider    ,   sess_options=self.gpu_options    ,   )
								pipe.set_progress_bar_config(disable=lowerCAmelCase_  )

								_snake_case   						=		'A fantasy landscape, trending on artstation'

								_snake_case   						=		np.random.RandomState(0  )
								_snake_case   						=		pipe(
								    prompt=lowerCAmelCase_    ,   image=lowerCAmelCase_    ,   strength=0.75    ,   guidance_scale=7.5    ,   num_inference_steps=20    ,   generator=lowerCAmelCase_    ,   output_type='np'    ,   )
								_snake_case   						=		output.images
								_snake_case   						=		images[0, 2_55:2_58, 3_83:3_86, -1]

								assert images.shape == (1, 5_12, 7_68, 3)
								_snake_case   						=		np.array([0.8043, 0.926, 0.9581, 0.8119, 0.8954, 0.913, 0.7209, 0.7463, 0.7431]  )
								# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 2E-2








'''simple docstring'''




import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel

  if is_vision_available():
    from transformers import MaskFormerImageProcessor

if is_vision_available():
  from PIL import Image







class   A_	:




 def __init__(					self       :    str	,			snake_case_       :    int	,			snake_case_       :    Union[str, Any]=2	,			snake_case_       :    List[Any]=True	,			snake_case_       :    str=False	,			snake_case_       :    str=1_0	,			snake_case_       :    str=3	,			snake_case_       :    Dict=3_2 * 4	,			snake_case_       :    Any=3_2 * 6	,			snake_case_       :    Optional[Any]=4	,			snake_case_       :    Optional[int]=3_2	,			):
      _UpperCAmelCase     							=   parent
      _UpperCAmelCase     							=   batch_size
      _UpperCAmelCase     							=   is_training
      _UpperCAmelCase     							=   use_auxiliary_loss
      _UpperCAmelCase     							=   num_queries
      _UpperCAmelCase     							=   num_channels
      _UpperCAmelCase     							=   min_size
      _UpperCAmelCase     							=   max_size
      _UpperCAmelCase     							=   num_labels
      _UpperCAmelCase     							=   mask_feature_size




 def      lowercase	(					self       :    Union[str, Any]    ):
      _UpperCAmelCase     							=   floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]    ).to(
          snake_case_    )

      _UpperCAmelCase     							=   torch.ones([self.batch_size, self.min_size, self.max_size]	,			device=snake_case_    )

      _UpperCAmelCase     							=   (
          torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]	,			device=snake_case_    ) > 0.5
      ).float()
      _UpperCAmelCase     							=   (torch.rand((self.batch_size, self.num_labels)	,			device=snake_case_    ) > 0.5).long()

      _UpperCAmelCase     							=   self.get_config()
      return config, pixel_values, pixel_mask, mask_labels, class_labels




 def      lowercase	(					self       :    List[Any]    ):
      return MaskFormerConfig.from_backbone_and_decoder_configs(
          backbone_config=SwinConfig(
              depths=[1, 1, 1, 1]	,			)	,			decoder_config=DetrConfig(
              decoder_ffn_dim=1_2_8	,			num_queries=self.num_queries	,			decoder_attention_heads=2	,			d_model=self.mask_feature_size	,			)	,			mask_feature_size=self.mask_feature_size	,			fpn_feature_size=self.mask_feature_size	,			num_channels=self.num_channels	,			num_labels=self.num_labels	,			)




 def      lowercase	(					self       :    Optional[Any]    ):
      _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase     							=   self.prepare_config_and_inputs()
      _UpperCAmelCase     							=   {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
      return config, inputs_dict




 def      lowercase	(					self       :    List[Any]	,			snake_case_       :    Optional[Any]	,			snake_case_       :    Optional[Any]    ):
      _UpperCAmelCase     							=   output.encoder_hidden_states
      _UpperCAmelCase     							=   output.pixel_decoder_hidden_states
      _UpperCAmelCase     							=   output.transformer_decoder_hidden_states

      self.parent.assertTrue(len(snake_case_    )	,			len(config.backbone_config.depths    )    )
      self.parent.assertTrue(len(snake_case_    )	,			len(config.backbone_config.depths    )    )
      self.parent.assertTrue(len(snake_case_    )	,			config.decoder_config.decoder_layers    )




 def      lowercase	(					self       :    Tuple	,			snake_case_       :    str	,			snake_case_       :    Optional[int]	,			snake_case_       :    Any	,			snake_case_       :    Optional[Any]=False    ):
      with torch.no_grad():
           _UpperCAmelCase     							=   MaskFormerModel(config=snake_case_    )
           model.to(snake_case_    )
           model.eval()

           _UpperCAmelCase     							=   model(pixel_values=snake_case_	,			pixel_mask=snake_case_    )
           _UpperCAmelCase     							=   model(snake_case_	,			output_hidden_states=snake_case_    )
      # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the
      # encoder and pixel decoder
      self.parent.assertEqual(
          output.transformer_decoder_last_hidden_state.shape	,			(self.batch_size, self.num_queries, self.mask_feature_size)	,			)
      # let's ensure the other two hidden state exists
      self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None    )
      self.parent.assertTrue(output.encoder_last_hidden_state is not None    )

      if output_hidden_states:
           self.check_output_hidden_state(snake_case_	,			snake_case_    )




 def      lowercase	(					self       :    Any	,			snake_case_       :    List[str]	,			snake_case_       :    List[Any]	,			snake_case_       :    int	,			snake_case_       :    str	,			snake_case_       :    List[Any]    ):
      _UpperCAmelCase     							=   MaskFormerForInstanceSegmentation(config=snake_case_    )
      model.to(snake_case_    )
      model.eval()

      def comm_check_on_output(snake_case_       :    int    ):
           # let's still check that all the required stuff is there
           self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None    )
           self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None    )
           self.parent.assertTrue(result.encoder_last_hidden_state is not None    )
           # okay, now we need to check the logits shape
           # due to the encoder compression, masks have a //4 spatial size
           self.parent.assertEqual(
               result.masks_queries_logits.shape	,			(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)	,			)
           # + 1 for null class
           self.parent.assertEqual(
               result.class_queries_logits.shape	,			(self.batch_size, self.num_queries, self.num_labels + 1)    )

      with torch.no_grad():
           _UpperCAmelCase     							=   model(pixel_values=snake_case_	,			pixel_mask=snake_case_    )
           _UpperCAmelCase     							=   model(snake_case_    )

           comm_check_on_output(snake_case_    )

           _UpperCAmelCase     							=   model(
               pixel_values=snake_case_	,			pixel_mask=snake_case_	,			mask_labels=snake_case_	,			class_labels=snake_case_    )

      comm_check_on_output(snake_case_    )

      self.parent.assertTrue(result.loss is not None    )
      self.parent.assertEqual(result.loss.shape	,			torch.Size([1]    )    )







@require_torch
class   A_	(  lowerCAmelCase_							,						lowerCAmelCase_							,						unittest.TestCase			):
 _lowerCamelCase  : Dict           =							(MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
 _lowerCamelCase  : Tuple           =							(
     {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation}
     if is_torch_available()
     else {}
 )

 _lowerCamelCase  : Optional[Any]           =							False
 _lowerCamelCase  : Dict           =							False
 _lowerCamelCase  : Any           =							False
 _lowerCamelCase  : List[Any]           =							False




 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   MaskFormerModelTester(self    )
      _UpperCAmelCase     							=   ConfigTester(self	,			config_class=snake_case_	,			has_text_modality=snake_case_    )




 def      lowercase	(					self       :    Optional[Any]    ):
      self.config_tester.run_common_tests()




 def      lowercase	(					self       :    Union[str, Any]    ):
      _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.create_and_check_maskformer_model(snake_case_	,			**snake_case_	,			output_hidden_states=snake_case_    )




 def      lowercase	(					self       :    int    ):
      _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_    )




 @unittest.skip(reason="MaskFormer does not use inputs_embeds"    )
 def      lowercase	(					self       :    Any    ):
      pass




 @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method"    )
 def      lowercase	(					self       :    List[str]    ):
      pass




 @unittest.skip(reason="MaskFormer is not a generative model"    )
 def      lowercase	(					self       :    List[str]    ):
      pass




 @unittest.skip(reason="MaskFormer does not use token embeddings"    )
 def      lowercase	(					self       :    List[Any]    ):
      pass




 @require_torch_multi_gpu
 @unittest.skip(
     reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`"    )
 def      lowercase	(					self       :    Any    ):
      pass




 @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."    )
 def      lowercase	(					self       :    Union[str, Any]    ):
      pass




 def      lowercase	(					self       :    List[str]    ):
      _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      lowercase	(					self       :    Optional[int]    ):
      for model_name in ["facebook/maskformer-swin-small-coco"]:
           _UpperCAmelCase     							=   MaskFormerModel.from_pretrained(snake_case_    )
           self.assertIsNotNone(snake_case_    )




 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   (self.model_tester.min_size,) * 2
      _UpperCAmelCase     							=   {
          "pixel_values": torch.randn((2, 3, *size)	,			device=snake_case_    ),
          "mask_labels": torch.randn((2, 1_0, *size)	,			device=snake_case_    ),
          "class_labels": torch.zeros(2	,			1_0	,			device=snake_case_    ).long(),
      }

      _UpperCAmelCase     							=   MaskFormerForInstanceSegmentation(MaskFormerConfig()    ).to(snake_case_    )
      _UpperCAmelCase     							=   model(**snake_case_    )
      self.assertTrue(outputs.loss is not None    )




 def      lowercase	(					self       :    Dict    ):
      _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.create_and_check_maskformer_model(snake_case_	,			**snake_case_	,			output_hidden_states=snake_case_    )




 def      lowercase	(					self       :    Any    ):
      _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _UpperCAmelCase     							=   model_class(snake_case_    ).to(snake_case_    )
           _UpperCAmelCase     							=   model(**snake_case_	,			output_attentions=snake_case_    )
           self.assertTrue(outputs.attentions is not None    )




 def      lowercase	(					self       :    int    ):
      if not self.model_tester.is_training:
           return
      # only MaskFormerForInstanceSegmentation has the loss
      _UpperCAmelCase     							=   self.all_model_classes[1]
      _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs()

      _UpperCAmelCase     							=   model_class(snake_case_    )
      model.to(snake_case_    )
      model.train()

      _UpperCAmelCase     							=   model(snake_case_	,			mask_labels=snake_case_	,			class_labels=snake_case_    ).loss
      loss.backward()




 def      lowercase	(					self       :    int    ):
      # only MaskFormerForInstanceSegmentation has the loss
      _UpperCAmelCase     							=   self.all_model_classes[1]
      _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs()
      _UpperCAmelCase     							=   True
      _UpperCAmelCase     							=   True

      _UpperCAmelCase     							=   model_class(snake_case_    )
      model.to(snake_case_    )
      model.train()

      _UpperCAmelCase     							=   model(snake_case_	,			mask_labels=snake_case_	,			class_labels=snake_case_    )

      _UpperCAmelCase     							=   outputs.encoder_hidden_states[0]
      encoder_hidden_states.retain_grad()

      _UpperCAmelCase     							=   outputs.pixel_decoder_hidden_states[0]
      pixel_decoder_hidden_states.retain_grad()
      # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't
      _UpperCAmelCase     							=   outputs.transformer_decoder_hidden_states[0]
      transformer_decoder_hidden_states.retain_grad()

      _UpperCAmelCase     							=   outputs.attentions[0]
      attentions.retain_grad()

      outputs.loss.backward(retain_graph=snake_case_    )

      self.assertIsNotNone(encoder_hidden_states.grad    )
      self.assertIsNotNone(pixel_decoder_hidden_states.grad    )
      self.assertIsNotNone(transformer_decoder_hidden_states.grad    )
      self.assertIsNotNone(attentions.grad    )





__SCREAMING_SNAKE_CASE     :Dict       =				1e-4
def 	UpperCAmelCase_							(					)		->       List[str]:


     '''simple docstring'''



     _UpperCAmelCase     							=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
     return image







@require_vision
@slow
class   A_	(  unittest.TestCase			):




 @cached_property
 def      lowercase	(					self       :    Dict    ):
      return (
          MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco"    )
          if is_vision_available()
          else None
      )




 def      lowercase	(					self       :    List[Any]    ):
      _UpperCAmelCase     							=   MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco"    ).to(snake_case_    )
      _UpperCAmelCase     							=   self.default_image_processor
      _UpperCAmelCase     							=   prepare_img()
      _UpperCAmelCase     							=   image_processor(snake_case_	,			return_tensors="pt"    ).to(snake_case_    )
      _UpperCAmelCase     							=   inputs["pixel_values"].shape
      # check size is divisible by 32
      self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0    )
      # check size
      self.assertEqual(snake_case_	,			(1, 3, 8_0_0, 1_0_8_8)    )

      with torch.no_grad():
           _UpperCAmelCase     							=   model(**snake_case_    )

      _UpperCAmelCase     							=   torch.tensor(
          [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]]    ).to(snake_case_    )
      self.assertTrue(
          torch.allclose(
              outputs.encoder_last_hidden_state[0, 0, :3, :3]	,			snake_case_	,			atol=snake_case_    )    )

      _UpperCAmelCase     							=   torch.tensor(
          [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]]    ).to(snake_case_    )
      self.assertTrue(
          torch.allclose(
              outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]	,			snake_case_	,			atol=snake_case_    )    )

      _UpperCAmelCase     							=   torch.tensor(
          [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]]    ).to(snake_case_    )
      self.assertTrue(
          torch.allclose(
              outputs.transformer_decoder_last_hidden_state[0, :3, :3]	,			snake_case_	,			atol=snake_case_    )    )




 def      lowercase	(					self       :    Tuple    ):
      _UpperCAmelCase     							=   (
          MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"    )
          .to(snake_case_    )
          .eval()
      )
      _UpperCAmelCase     							=   self.default_image_processor
      _UpperCAmelCase     							=   prepare_img()
      _UpperCAmelCase     							=   image_processor(snake_case_	,			return_tensors="pt"    ).to(snake_case_    )
      _UpperCAmelCase     							=   inputs["pixel_values"].shape
      # check size is divisible by 32
      self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0    )
      # check size
      self.assertEqual(snake_case_	,			(1, 3, 8_0_0, 1_0_8_8)    )

      with torch.no_grad():
           _UpperCAmelCase     							=   model(**snake_case_    )
      # masks_queries_logits
      _UpperCAmelCase     							=   outputs.masks_queries_logits
      self.assertEqual(
          masks_queries_logits.shape	,			(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)	,			)
      _UpperCAmelCase     							=   [
          [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3],
          [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5],
          [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2],
      ]
      _UpperCAmelCase     							=   torch.tensor(snake_case_    ).to(snake_case_    )
      self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]	,			snake_case_	,			atol=snake_case_    )    )
      # class_queries_logits
      _UpperCAmelCase     							=   outputs.class_queries_logits
      self.assertEqual(
          class_queries_logits.shape	,			(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)    )
      _UpperCAmelCase     							=   torch.tensor(
          [
              [1.6_512e00, -5.2_572e00, -3.3_519e00],
              [3.6_169e-02, -5.9_025e00, -2.9_313e00],
              [1.0_766e-04, -7.7_630e00, -5.1_263e00],
          ]    ).to(snake_case_    )
      self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]	,			snake_case_	,			atol=snake_case_    )    )




 def      lowercase	(					self       :    int    ):
      _UpperCAmelCase     							=   (
          MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff"    )
          .to(snake_case_    )
          .eval()
      )
      _UpperCAmelCase     							=   self.default_image_processor
      _UpperCAmelCase     							=   prepare_img()
      _UpperCAmelCase     							=   image_processor(snake_case_	,			return_tensors="pt"    ).to(snake_case_    )
      _UpperCAmelCase     							=   inputs["pixel_values"].shape
      # check size is divisible by 32
      self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0    )
      # check size
      self.assertEqual(snake_case_	,			(1, 3, 8_0_0, 1_0_8_8)    )

      with torch.no_grad():
           _UpperCAmelCase     							=   model(**snake_case_    )
      # masks_queries_logits
      _UpperCAmelCase     							=   outputs.masks_queries_logits
      self.assertEqual(
          masks_queries_logits.shape	,			(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)	,			)
      _UpperCAmelCase     							=   [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]]
      _UpperCAmelCase     							=   torch.tensor(snake_case_    ).to(snake_case_    )
      self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]	,			snake_case_	,			atol=snake_case_    )    )
      # class_queries_logits
      _UpperCAmelCase     							=   outputs.class_queries_logits
      self.assertEqual(
          class_queries_logits.shape	,			(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)    )
      _UpperCAmelCase     							=   torch.tensor(
          [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]]    ).to(snake_case_    )
      self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]	,			snake_case_	,			atol=snake_case_    )    )




 def      lowercase	(					self       :    List[Any]    ):
      _UpperCAmelCase     							=   (
          MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"    )
          .to(snake_case_    )
          .eval()
      )
      _UpperCAmelCase     							=   self.default_image_processor

      _UpperCAmelCase     							=   image_processor(
          [np.zeros((3, 8_0_0, 1_3_3_3)    ), np.zeros((3, 8_0_0, 1_3_3_3)    )]	,			segmentation_maps=[np.zeros((3_8_4, 3_8_4)    ).astype(np.floataa    ), np.zeros((3_8_4, 3_8_4)    ).astype(np.floataa    )]	,			return_tensors="pt"	,			)

      _UpperCAmelCase     							=   inputs["pixel_values"].to(snake_case_    )
      _UpperCAmelCase     							=   [el.to(snake_case_    ) for el in inputs["mask_labels"]]
      _UpperCAmelCase     							=   [el.to(snake_case_    ) for el in inputs["class_labels"]]

      with torch.no_grad():
           _UpperCAmelCase     							=   model(**snake_case_    )

      self.assertTrue(outputs.loss is not None    )




