






import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()




class     A    (      unittest.TestCase						):






 """simple docstring"""





 def   _UpperCAmelCase       (							self ):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
 @property
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[Any]					    =							1
       UpperCamelCase_				:   List[str]					    =							3
       UpperCamelCase_				:   List[Any]					    =							(32, 32)

       UpperCamelCase_				:   Union[str, Any]					    =							floats_tensor((batch_size, num_channels) + sizes			,     rng=random.Random(0 ) ).to(__lowerCAmelCase )
       return image
 @property
 def   _UpperCAmelCase       (							self ):
       torch.manual_seed(0 )
       UpperCamelCase_				:   List[str]					    =							UNetaDConditionModel(
           block_out_channels=(32, 32, 64)			,     layers_per_block=2			,     sample_size=32			,     in_channels=7			,     out_channels=4			,     down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""", """CrossAttnDownBlock2D""")			,     up_block_types=("""CrossAttnUpBlock2D""", """CrossAttnUpBlock2D""", """UpBlock2D""")			,     cross_attention_dim=32			,     attention_head_dim=8			,     use_linear_projection=__lowerCAmelCase			,     only_cross_attention=(True, True, False)			,     num_class_embeds=1_00			,     )
       return model
 @property
 def   _UpperCAmelCase       (							self ):
       torch.manual_seed(0 )
       UpperCamelCase_				:   Optional[Any]					    =							AutoencoderKL(
           block_out_channels=[32, 32, 64]			,     in_channels=3			,     out_channels=3			,     down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D""", """DownEncoderBlock2D"""]			,     up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D""", """UpDecoderBlock2D"""]			,     latent_channels=4			,     )
       return model
 @property
 def   _UpperCAmelCase       (							self ):
       torch.manual_seed(0 )
       UpperCamelCase_				:   List[Any]					    =							CLIPTextConfig(
           bos_token_id=0			,     eos_token_id=2			,     hidden_size=32			,     intermediate_size=37			,     layer_norm_eps=1E-05			,     num_attention_heads=4			,     num_hidden_layers=5			,     pad_token_id=1			,     vocab_size=10_00			,     hidden_act="""gelu"""			,     projection_dim=5_12			,     )
       return CLIPTextModel(__lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[int]					    =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
       UpperCamelCase_				:   List[str]					    =							self.dummy_cond_unet_upscale
       UpperCamelCase_				:   str					    =							DDPMScheduler()
       UpperCamelCase_				:   Dict					    =							DDIMScheduler(prediction_type="""v_prediction""" )
       UpperCamelCase_				:   Optional[int]					    =							self.dummy_vae
       UpperCamelCase_				:   Dict					    =							self.dummy_text_encoder
       UpperCamelCase_				:   Dict					    =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

       UpperCamelCase_				:   List[Any]					    =							self.dummy_image.cpu().permute(0			,     2			,     3			,     1 )[0]
       UpperCamelCase_				:   List[str]					    =							Image.fromarray(np.uinta(__lowerCAmelCase ) ).convert("""RGB""" ).resize((64, 64) )

       # make sure here that pndm scheduler skips prk
       UpperCamelCase_				:   int					    =							StableDiffusionUpscalePipeline(
           unet=__lowerCAmelCase			,     low_res_scheduler=__lowerCAmelCase			,     scheduler=__lowerCAmelCase			,     vae=__lowerCAmelCase			,     text_encoder=__lowerCAmelCase			,     tokenizer=__lowerCAmelCase			,     max_noise_level=3_50			,     )
       UpperCamelCase_				:   List[Any]					    =							sd_pipe.to(__lowerCAmelCase )
       sd_pipe.set_progress_bar_config(disable=__lowerCAmelCase )

       UpperCamelCase_				:   Dict					    =							"""A painting of a squirrel eating a burger"""
       UpperCamelCase_				:   Tuple					    =							torch.Generator(device=__lowerCAmelCase ).manual_seed(0 )
       UpperCamelCase_				:   Any					    =							sd_pipe(
           [prompt]			,     image=__lowerCAmelCase			,     generator=__lowerCAmelCase			,     guidance_scale=6.0			,     noise_level=20			,     num_inference_steps=2			,     output_type="""np"""			,     )

       UpperCamelCase_				:   int					    =							output.images

       UpperCamelCase_				:   Tuple					    =							torch.Generator(device=__lowerCAmelCase ).manual_seed(0 )
       UpperCamelCase_				:   List[str]					    =							sd_pipe(
           [prompt]			,     image=__lowerCAmelCase			,     generator=__lowerCAmelCase			,     guidance_scale=6.0			,     noise_level=20			,     num_inference_steps=2			,     output_type="""np"""			,     return_dict=__lowerCAmelCase			,     )[0]

       UpperCamelCase_				:   List[Any]					    =							image[0, -3:, -3:, -1]
       UpperCamelCase_				:   int					    =							image_from_tuple[0, -3:, -3:, -1]

       UpperCamelCase_				:   Optional[Any]					    =							low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)
       UpperCamelCase_				:   Union[str, Any]					    =							np.array([0.31_13, 0.39_10, 0.42_72, 0.48_59, 0.50_61, 0.46_52, 0.53_62, 0.57_15, 0.56_61] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Any					    =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
       UpperCamelCase_				:   str					    =							self.dummy_cond_unet_upscale
       UpperCamelCase_				:   List[Any]					    =							DDPMScheduler()
       UpperCamelCase_				:   Tuple					    =							DDIMScheduler(prediction_type="""v_prediction""" )
       UpperCamelCase_				:   str					    =							self.dummy_vae
       UpperCamelCase_				:   List[str]					    =							self.dummy_text_encoder
       UpperCamelCase_				:   Optional[int]					    =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

       UpperCamelCase_				:   int					    =							self.dummy_image.cpu().permute(0			,     2			,     3			,     1 )[0]
       UpperCamelCase_				:   Tuple					    =							Image.fromarray(np.uinta(__lowerCAmelCase ) ).convert("""RGB""" ).resize((64, 64) )

       # make sure here that pndm scheduler skips prk
       UpperCamelCase_				:   Tuple					    =							StableDiffusionUpscalePipeline(
           unet=__lowerCAmelCase			,     low_res_scheduler=__lowerCAmelCase			,     scheduler=__lowerCAmelCase			,     vae=__lowerCAmelCase			,     text_encoder=__lowerCAmelCase			,     tokenizer=__lowerCAmelCase			,     max_noise_level=3_50			,     )
       UpperCamelCase_				:   List[str]					    =							sd_pipe.to(__lowerCAmelCase )
       sd_pipe.set_progress_bar_config(disable=__lowerCAmelCase )

       UpperCamelCase_				:   Dict					    =							"""A painting of a squirrel eating a burger"""
       UpperCamelCase_				:   Optional[int]					    =							sd_pipe(
           2 * [prompt]			,     image=2 * [low_res_image]			,     guidance_scale=6.0			,     noise_level=20			,     num_inference_steps=2			,     output_type="""np"""			,     )
       UpperCamelCase_				:   Tuple					    =							output.images
       assert image.shape[0] == 2

       UpperCamelCase_				:   Any					    =							torch.Generator(device=__lowerCAmelCase ).manual_seed(0 )
       UpperCamelCase_				:   Any					    =							sd_pipe(
           [prompt]			,     image=__lowerCAmelCase			,     generator=__lowerCAmelCase			,     num_images_per_prompt=2			,     guidance_scale=6.0			,     noise_level=20			,     num_inference_steps=2			,     output_type="""np"""			,     )
       UpperCamelCase_				:   str					    =							output.images
       assert image.shape[0] == 2





 @unittest.skipIf(torch_device != """cuda"""			,     """This test requires a GPU""" )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							self.dummy_cond_unet_upscale
       UpperCamelCase_				:   Optional[int]					    =							DDPMScheduler()
       UpperCamelCase_				:   List[str]					    =							DDIMScheduler(prediction_type="""v_prediction""" )
       UpperCamelCase_				:   Any					    =							self.dummy_vae
       UpperCamelCase_				:   List[Any]					    =							self.dummy_text_encoder
       UpperCamelCase_				:   List[str]					    =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

       UpperCamelCase_				:   Tuple					    =							self.dummy_image.cpu().permute(0			,     2			,     3			,     1 )[0]
       UpperCamelCase_				:   Optional[int]					    =							Image.fromarray(np.uinta(__lowerCAmelCase ) ).convert("""RGB""" ).resize((64, 64) )

       # put models in fp16, except vae as it overflows in fp16
       UpperCamelCase_				:   Any					    =							unet.half()
       UpperCamelCase_				:   Optional[int]					    =							text_encoder.half()

       # make sure here that pndm scheduler skips prk
       UpperCamelCase_				:   Optional[Any]					    =							StableDiffusionUpscalePipeline(
           unet=__lowerCAmelCase			,     low_res_scheduler=__lowerCAmelCase			,     scheduler=__lowerCAmelCase			,     vae=__lowerCAmelCase			,     text_encoder=__lowerCAmelCase			,     tokenizer=__lowerCAmelCase			,     max_noise_level=3_50			,     )
       UpperCamelCase_				:   List[str]					    =							sd_pipe.to(__lowerCAmelCase )
       sd_pipe.set_progress_bar_config(disable=__lowerCAmelCase )

       UpperCamelCase_				:   Any					    =							"""A painting of a squirrel eating a burger"""
       UpperCamelCase_				:   Optional[int]					    =							torch.manual_seed(0 )
       UpperCamelCase_				:   str					    =							sd_pipe(
           [prompt]			,     image=__lowerCAmelCase			,     generator=__lowerCAmelCase			,     num_inference_steps=2			,     output_type="""np"""			,     ).images

       UpperCamelCase_				:   Optional[Any]					    =							low_res_image.size[0] * 4
       assert image.shape == (1, expected_height_width, expected_height_width, 3)






@slow
@require_torch_gpu
class     A    (      unittest.TestCase						):






 """simple docstring"""





 def   _UpperCAmelCase       (							self ):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Union[str, Any]					    =							load_image(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
           """/sd2-upscale/low_res_cat.png""" )
       UpperCamelCase_				:   Optional[Any]					    =							load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
           """/upsampled_cat.npy""" )

       UpperCamelCase_				:   int					    =							"""stabilityai/stable-diffusion-x4-upscaler"""
       UpperCamelCase_				:   List[Any]					    =							StableDiffusionUpscalePipeline.from_pretrained(__lowerCAmelCase )
       pipe.to(__lowerCAmelCase )
       pipe.set_progress_bar_config(disable=__lowerCAmelCase )
       pipe.enable_attention_slicing()

       UpperCamelCase_				:   Union[str, Any]					    =							"""a cat sitting on a park bench"""

       UpperCamelCase_				:   int					    =							torch.manual_seed(0 )
       UpperCamelCase_				:   int					    =							pipe(
           prompt=__lowerCAmelCase			,     image=__lowerCAmelCase			,     generator=__lowerCAmelCase			,     output_type="""np"""			,     )
       UpperCamelCase_				:   Optional[Any]					    =							output.images[0]

       assert image.shape == (5_12, 5_12, 3)
       assert np.abs(expected_image - image ).max() < 1E-3
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   List[str]					    =							load_image(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
           """/sd2-upscale/low_res_cat.png""" )
       UpperCamelCase_				:   Tuple					    =							load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
           """/upsampled_cat_fp16.npy""" )

       UpperCamelCase_				:   str					    =							"""stabilityai/stable-diffusion-x4-upscaler"""
       UpperCamelCase_				:   Tuple					    =							StableDiffusionUpscalePipeline.from_pretrained(
           __lowerCAmelCase			,     torch_dtype=torch.floataa			,     )
       pipe.to(__lowerCAmelCase )
       pipe.set_progress_bar_config(disable=__lowerCAmelCase )
       pipe.enable_attention_slicing()

       UpperCamelCase_				:   Union[str, Any]					    =							"""a cat sitting on a park bench"""

       UpperCamelCase_				:   str					    =							torch.manual_seed(0 )
       UpperCamelCase_				:   Optional[Any]					    =							pipe(
           prompt=__lowerCAmelCase			,     image=__lowerCAmelCase			,     generator=__lowerCAmelCase			,     output_type="""np"""			,     )
       UpperCamelCase_				:   Union[str, Any]					    =							output.images[0]

       assert image.shape == (5_12, 5_12, 3)
       assert np.abs(expected_image - image ).max() < 5E-1





 def   _UpperCAmelCase       (							self ):
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       UpperCamelCase_				:   Optional[int]					    =							load_image(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
           """/sd2-upscale/low_res_cat.png""" )

       UpperCamelCase_				:   Union[str, Any]					    =							"""stabilityai/stable-diffusion-x4-upscaler"""
       UpperCamelCase_				:   Union[str, Any]					    =							StableDiffusionUpscalePipeline.from_pretrained(
           __lowerCAmelCase			,     torch_dtype=torch.floataa			,     )
       pipe.to(__lowerCAmelCase )
       pipe.set_progress_bar_config(disable=__lowerCAmelCase )
       pipe.enable_attention_slicing(1 )
       pipe.enable_sequential_cpu_offload()

       UpperCamelCase_				:   List[Any]					    =							"""a cat sitting on a park bench"""

       UpperCamelCase_				:   int					    =							torch.manual_seed(0 )
       UpperCamelCase_				:   Any					    =							pipe(
           prompt=__lowerCAmelCase			,     image=__lowerCAmelCase			,     generator=__lowerCAmelCase			,     num_inference_steps=5			,     output_type="""np"""			,     )

       UpperCamelCase_				:   List[str]					    =							torch.cuda.max_memory_allocated()
       # make sure that less than 2.9 GB is allocated
       assert mem_bytes < 2.9 * 10**9














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






 """simple docstring"""





 def __init__(							self			,     __lowerCAmelCase			,     __lowerCAmelCase=2			,     __lowerCAmelCase=True			,     __lowerCAmelCase=False			,     __lowerCAmelCase=10			,     __lowerCAmelCase=3			,     __lowerCAmelCase=32 * 4			,     __lowerCAmelCase=32 * 6			,     __lowerCAmelCase=4			,     __lowerCAmelCase=32			,     ):
       UpperCamelCase_				:   List[str]					    =							parent
       UpperCamelCase_				:   List[Any]					    =							batch_size
       UpperCamelCase_				:   int					    =							is_training
       UpperCamelCase_				:   Union[str, Any]					    =							use_auxiliary_loss
       UpperCamelCase_				:   Optional[Any]					    =							num_queries
       UpperCamelCase_				:   List[str]					    =							num_channels
       UpperCamelCase_				:   Optional[int]					    =							min_size
       UpperCamelCase_				:   Union[str, Any]					    =							max_size
       UpperCamelCase_				:   Optional[int]					    =							num_labels
       UpperCamelCase_				:   List[Any]					    =							mask_feature_size
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   str					    =							floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to(
           __lowerCAmelCase )

       UpperCamelCase_				:   Union[str, Any]					    =							torch.ones([self.batch_size, self.min_size, self.max_size]			,     device=__lowerCAmelCase )

       UpperCamelCase_				:   Dict					    =							(
           torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]			,     device=__lowerCAmelCase ) > 0.5
       ).float()
       UpperCamelCase_				:   List[Any]					    =							(torch.rand((self.batch_size, self.num_labels)			,     device=__lowerCAmelCase ) > 0.5).long()

       UpperCamelCase_				:   Dict					    =							self.get_config()
       return config, pixel_values, pixel_mask, mask_labels, class_labels
 def   _UpperCAmelCase       (							self ):
       return MaskFormerConfig.from_backbone_and_decoder_configs(
           backbone_config=SwinConfig(
               depths=[1, 1, 1, 1]			,     )			,     decoder_config=DetrConfig(
               decoder_ffn_dim=1_28			,     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   _UpperCAmelCase       (							self ):
       UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_				:   Optional[Any]					    =							self.prepare_config_and_inputs()
       UpperCamelCase_				:   int					    =							{"""pixel_values""": pixel_values, """pixel_mask""": pixel_mask}
       return config, inputs_dict
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase ):
       UpperCamelCase_				:   List[str]					    =							output.encoder_hidden_states
       UpperCamelCase_				:   Any					    =							output.pixel_decoder_hidden_states
       UpperCamelCase_				:   Union[str, Any]					    =							output.transformer_decoder_hidden_states

       self.parent.assertTrue(len(__lowerCAmelCase )			,     len(config.backbone_config.depths ) )
       self.parent.assertTrue(len(__lowerCAmelCase )			,     len(config.backbone_config.depths ) )
       self.parent.assertTrue(len(__lowerCAmelCase )			,     config.decoder_config.decoder_layers )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase=False ):
       with torch.no_grad():
             UpperCamelCase_				:   Tuple					    =							MaskFormerModel(config=__lowerCAmelCase )
             model.to(__lowerCAmelCase )
             model.eval()

             UpperCamelCase_				:   str					    =							model(pixel_values=__lowerCAmelCase			,     pixel_mask=__lowerCAmelCase )
             UpperCamelCase_				:   Union[str, Any]					    =							model(__lowerCAmelCase			,     output_hidden_states=__lowerCAmelCase )
       # 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(__lowerCAmelCase			,     __lowerCAmelCase )





 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase ):
       UpperCamelCase_				:   Optional[int]					    =							MaskFormerForInstanceSegmentation(config=__lowerCAmelCase )
       model.to(__lowerCAmelCase )
       model.eval()

       def comm_check_on_output(__lowerCAmelCase ):
             # 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_				:   List[Any]					    =							model(pixel_values=__lowerCAmelCase			,     pixel_mask=__lowerCAmelCase )
             UpperCamelCase_				:   List[str]					    =							model(__lowerCAmelCase )

             comm_check_on_output(__lowerCAmelCase )

             UpperCamelCase_				:   Dict					    =							model(
                 pixel_values=__lowerCAmelCase			,     pixel_mask=__lowerCAmelCase			,     mask_labels=__lowerCAmelCase			,     class_labels=__lowerCAmelCase )

       comm_check_on_output(__lowerCAmelCase )

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






@require_torch
class     A    (      SCREAMING_SNAKE_CASE__,   SCREAMING_SNAKE_CASE__,   unittest.TestCase						):






 """simple docstring"""





 __a			:						Tuple      =						(MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
 __a			:						List[str]      =						(
     {'''feature-extraction''': MaskFormerModel, '''image-segmentation''': MaskFormerForInstanceSegmentation}
     if is_torch_available()
     else {}
 )

 __a			:						List[Any]      =						False
 __a			:						int      =						False
 __a			:						List[str]      =						False
 __a			:						Any      =						False
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[int]					    =							MaskFormerModelTester(self )
       UpperCamelCase_				:   Optional[int]					    =							ConfigTester(self			,     config_class=__lowerCAmelCase			,     has_text_modality=__lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       self.config_tester.run_common_tests()
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_    ,			UpperCamelCase_				:   List[str]					    =							self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskformer_model(__lowerCAmelCase			,     **__lowerCAmelCase			,     output_hidden_states=__lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*__lowerCAmelCase )
 @unittest.skip(reason="""MaskFormer does not use inputs_embeds""" )
 def   _UpperCAmelCase       (							self ):
       pass
 @unittest.skip(reason="""MaskFormer does not have a get_input_embeddings method""" )
 def   _UpperCAmelCase       (							self ):
       pass
 @unittest.skip(reason="""MaskFormer is not a generative model""" )
 def   _UpperCAmelCase       (							self ):
       pass
 @unittest.skip(reason="""MaskFormer does not use token embeddings""" )
 def   _UpperCAmelCase       (							self ):
       pass
 @require_torch_multi_gpu
 @unittest.skip(
     reason="""MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`""" )
 def   _UpperCAmelCase       (							self ):
       pass
 @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" )
 def   _UpperCAmelCase       (							self ):
       pass
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_    ,			UpperCamelCase_				:   Optional[int]					    =							self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             UpperCamelCase_				:   List[Any]					    =							model_class(__lowerCAmelCase )
             UpperCamelCase_				:   Union[str, Any]					    =							inspect.signature(model.forward )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             UpperCamelCase_				:   Optional[Any]					    =							[*signature.parameters.keys()]

             UpperCamelCase_				:   Any					    =							["""pixel_values"""]
             self.assertListEqual(arg_names[:1]			,     __lowerCAmelCase )
 @slow
 def   _UpperCAmelCase       (							self ):
       for model_name in ["facebook/maskformer-swin-small-coco"]:
             UpperCamelCase_				:   List[str]					    =							MaskFormerModel.from_pretrained(__lowerCAmelCase )
             self.assertIsNotNone(__lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Tuple					    =							(self.model_tester.min_size,) * 2
       UpperCamelCase_				:   Optional[int]					    =							{
           """pixel_values""": torch.randn((2, 3, *size)			,     device=__lowerCAmelCase ),
           """mask_labels""": torch.randn((2, 10, *size)			,     device=__lowerCAmelCase ),
           """class_labels""": torch.zeros(2			,     10			,     device=__lowerCAmelCase ).long(),
       }

       UpperCamelCase_				:   Union[str, Any]					    =							MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(__lowerCAmelCase )
       UpperCamelCase_				:   List[str]					    =							model(**__lowerCAmelCase )
       self.assertTrue(outputs.loss is not None )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_    ,			UpperCamelCase_				:   Dict					    =							self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskformer_model(__lowerCAmelCase			,     **__lowerCAmelCase			,     output_hidden_states=__lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_    ,			UpperCamelCase_				:   Tuple					    =							self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             UpperCamelCase_				:   Optional[int]					    =							model_class(__lowerCAmelCase ).to(__lowerCAmelCase )
             UpperCamelCase_				:   Optional[int]					    =							model(**__lowerCAmelCase			,     output_attentions=__lowerCAmelCase )
             self.assertTrue(outputs.attentions is not None )
 def   _UpperCAmelCase       (							self ):
       if not self.model_tester.is_training:
             return
       # only MaskFormerForInstanceSegmentation has the loss
       UpperCamelCase_				:   int					    =							self.all_model_classes[1]
       UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_				:   Tuple					    =							self.model_tester.prepare_config_and_inputs()

       UpperCamelCase_				:   Dict					    =							model_class(__lowerCAmelCase )
       model.to(__lowerCAmelCase )
       model.train()

       UpperCamelCase_				:   Union[str, Any]					    =							model(__lowerCAmelCase			,     mask_labels=__lowerCAmelCase			,     class_labels=__lowerCAmelCase ).loss
       loss.backward()





 def   _UpperCAmelCase       (							self ):
       # only MaskFormerForInstanceSegmentation has the loss
       UpperCamelCase_				:   List[Any]					    =							self.all_model_classes[1]
       UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_				:   Dict					    =							self.model_tester.prepare_config_and_inputs()
       UpperCamelCase_				:   Optional[int]					    =							True
       UpperCamelCase_				:   List[str]					    =							True

       UpperCamelCase_				:   Any					    =							model_class(__lowerCAmelCase )
       model.to(__lowerCAmelCase )
       model.train()

       UpperCamelCase_				:   Dict					    =							model(__lowerCAmelCase			,     mask_labels=__lowerCAmelCase			,     class_labels=__lowerCAmelCase )

       UpperCamelCase_				:   Optional[int]					    =							outputs.encoder_hidden_states[0]
       encoder_hidden_states.retain_grad()

       UpperCamelCase_				:   Optional[int]					    =							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_				:   List[str]					    =							outputs.transformer_decoder_hidden_states[0]
       transformer_decoder_hidden_states.retain_grad()

       UpperCamelCase_				:   List[Any]					    =							outputs.attentions[0]
       attentions.retain_grad()

       outputs.loss.backward(retain_graph=__lowerCAmelCase )

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






UpperCamelCase							=1E-4



def 							snake_case					(     )       ->				Union[str, Any]:





      """simple docstring"""

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




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






 """simple docstring"""





 @cached_property
 def   _UpperCAmelCase       (							self ):
       return (
           MaskFormerImageProcessor.from_pretrained("""facebook/maskformer-swin-small-coco""" )
           if is_vision_available()
           else None
       )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   List[Any]					    =							MaskFormerModel.from_pretrained("""facebook/maskformer-swin-small-coco""" ).to(__lowerCAmelCase )
       UpperCamelCase_				:   Optional[Any]					    =							self.default_image_processor
       UpperCamelCase_				:   Optional[int]					    =							prepare_img()
       UpperCamelCase_				:   Optional[int]					    =							image_processor(__lowerCAmelCase			,     return_tensors="""pt""" ).to(__lowerCAmelCase )
       UpperCamelCase_				:   Union[str, Any]					    =							inputs["""pixel_values"""].shape
       # check size is divisible by 32
       self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
       # check size
       self.assertEqual(__lowerCAmelCase			,     (1, 3, 8_00, 10_88) )

       with torch.no_grad():
             UpperCamelCase_				:   Tuple					    =							model(**__lowerCAmelCase )

       UpperCamelCase_				:   str					    =							torch.tensor(
           [[-0.04_82, 0.92_28, 0.49_51], [-0.25_47, 0.80_17, 0.85_27], [-0.00_69, 0.33_85, -0.00_89]] ).to(__lowerCAmelCase )
       self.assertTrue(
           torch.allclose(
               outputs.encoder_last_hidden_state[0, 0, :3, :3]			,     __lowerCAmelCase			,     atol=__lowerCAmelCase ) )

       UpperCamelCase_				:   Any					    =							torch.tensor(
           [[-0.84_22, -0.84_34, -0.97_18], [-1.01_44, -0.55_65, -0.41_95], [-1.00_38, -0.44_84, -0.19_61]] ).to(__lowerCAmelCase )
       self.assertTrue(
           torch.allclose(
               outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]			,     __lowerCAmelCase			,     atol=__lowerCAmelCase ) )

       UpperCamelCase_				:   List[Any]					    =							torch.tensor(
           [[0.28_52, -0.01_59, 0.97_35], [0.62_54, 0.18_58, 0.85_29], [-0.06_80, -0.41_16, 1.84_13]] ).to(__lowerCAmelCase )
       self.assertTrue(
           torch.allclose(
               outputs.transformer_decoder_last_hidden_state[0, :3, :3]			,     __lowerCAmelCase			,     atol=__lowerCAmelCase ) )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[int]					    =							(
           MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-swin-small-coco""" )
           .to(__lowerCAmelCase )
           .eval()
       )
       UpperCamelCase_				:   int					    =							self.default_image_processor
       UpperCamelCase_				:   Tuple					    =							prepare_img()
       UpperCamelCase_				:   Optional[Any]					    =							image_processor(__lowerCAmelCase			,     return_tensors="""pt""" ).to(__lowerCAmelCase )
       UpperCamelCase_				:   List[Any]					    =							inputs["""pixel_values"""].shape
       # check size is divisible by 32
       self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
       # check size
       self.assertEqual(__lowerCAmelCase			,     (1, 3, 8_00, 10_88) )

       with torch.no_grad():
             UpperCamelCase_				:   List[str]					    =							model(**__lowerCAmelCase )
       # masks_queries_logits
       UpperCamelCase_				:   Any					    =							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_				:   Union[str, Any]					    =							[
           [-1.3_73_71_24, -1.7_72_49_37, -1.9_36_42_33],
           [-1.5_97_72_81, -1.9_86_79_39, -2.1_52_36_95],
           [-1.5_79_53_98, -1.9_26_98_32, -2.09_39_42],
       ]
       UpperCamelCase_				:   Optional[Any]					    =							torch.tensor(__lowerCAmelCase ).to(__lowerCAmelCase )
       self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]			,     __lowerCAmelCase			,     atol=__lowerCAmelCase ) )
       # class_queries_logits
       UpperCamelCase_				:   List[str]					    =							outputs.class_queries_logits
       self.assertEqual(
           class_queries_logits.shape			,     (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) )
       UpperCamelCase_				:   Optional[Any]					    =							torch.tensor(
           [
               [1.6512E00, -5.2572E00, -3.3519E00],
               [3.6169E-02, -5.9025E00, -2.9313E00],
               [1.0766E-04, -7.7630E00, -5.1263E00],
           ] ).to(__lowerCAmelCase )
       self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]			,     __lowerCAmelCase			,     atol=__lowerCAmelCase ) )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[int]					    =							(
           MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-resnet101-coco-stuff""" )
           .to(__lowerCAmelCase )
           .eval()
       )
       UpperCamelCase_				:   Optional[int]					    =							self.default_image_processor
       UpperCamelCase_				:   Optional[Any]					    =							prepare_img()
       UpperCamelCase_				:   str					    =							image_processor(__lowerCAmelCase			,     return_tensors="""pt""" ).to(__lowerCAmelCase )
       UpperCamelCase_				:   Union[str, Any]					    =							inputs["""pixel_values"""].shape
       # check size is divisible by 32
       self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
       # check size
       self.assertEqual(__lowerCAmelCase			,     (1, 3, 8_00, 10_88) )

       with torch.no_grad():
             UpperCamelCase_				:   List[Any]					    =							model(**__lowerCAmelCase )
       # masks_queries_logits
       UpperCamelCase_				:   Union[str, Any]					    =							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_				:   List[str]					    =							[[-0.90_46, -2.63_66, -4.60_62], [-3.41_79, -5.78_90, -8.80_57], [-4.91_79, -7.65_60, -10.77_11]]
       UpperCamelCase_				:   Any					    =							torch.tensor(__lowerCAmelCase ).to(__lowerCAmelCase )
       self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]			,     __lowerCAmelCase			,     atol=__lowerCAmelCase ) )
       # class_queries_logits
       UpperCamelCase_				:   List[Any]					    =							outputs.class_queries_logits
       self.assertEqual(
           class_queries_logits.shape			,     (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) )
       UpperCamelCase_				:   Any					    =							torch.tensor(
           [[4.71_88, -3.25_85, -2.88_57], [6.68_71, -2.91_81, -1.24_87], [7.24_49, -2.27_64, -2.18_74]] ).to(__lowerCAmelCase )
       self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]			,     __lowerCAmelCase			,     atol=__lowerCAmelCase ) )





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

       UpperCamelCase_				:   Tuple					    =							image_processor(
           [np.zeros((3, 8_00, 13_33) ), np.zeros((3, 8_00, 13_33) )]			,     segmentation_maps=[np.zeros((3_84, 3_84) ).astype(np.floataa ), np.zeros((3_84, 3_84) ).astype(np.floataa )]			,     return_tensors="""pt"""			,     )

       UpperCamelCase_				:   List[Any]					    =							inputs["""pixel_values"""].to(__lowerCAmelCase )
       UpperCamelCase_				:   List[Any]					    =							[el.to(__lowerCAmelCase ) for el in inputs["""mask_labels"""]]
       UpperCamelCase_				:   Tuple					    =							[el.to(__lowerCAmelCase ) for el in inputs["""class_labels"""]]

       with torch.no_grad():
             UpperCamelCase_				:   Union[str, Any]					    =							model(**__lowerCAmelCase )

       self.assertTrue(outputs.loss is not None )






