


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  :	List[Any]							,				snake_case  :	Dict							,				snake_case  :	List[str]=2							,				snake_case  :	List[Any]=True							,				snake_case  :	Union[str, Any]=False							,				snake_case  :	int=10							,				snake_case  :	Tuple=3							,				snake_case  :	Any=32 * 4							,				snake_case  :	str=32 * 6							,				snake_case  :	str=4							,				snake_case  :	Union[str, Any]=32							,				)		->							Any:
          __UpperCAmelCase			:				Any													=    parent
          __UpperCAmelCase			:				List[Any]													=    batch_size
          __UpperCAmelCase			:				str													=    is_training
          __UpperCAmelCase			:				Dict													=    use_auxiliary_loss
          __UpperCAmelCase			:				Union[str, Any]													=    num_queries
          __UpperCAmelCase			:				List[Any]													=    num_channels
          __UpperCAmelCase			:				Optional[int]													=    min_size
          __UpperCAmelCase			:				Tuple													=    max_size
          __UpperCAmelCase			:				List[str]													=    num_labels
          __UpperCAmelCase			:				Dict													=    mask_feature_size

     def 				lowerCamelCase__				(       self  :	int    )		->							Tuple:
          __UpperCAmelCase			:				Dict													=    floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]    ).to(
              _lowerCAmelCase    )

          __UpperCAmelCase			:				Tuple													=    torch.ones([self.batch_size, self.min_size, self.max_size]							,				device=_lowerCAmelCase    )

          __UpperCAmelCase			:				int													=    (
              torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]							,				device=_lowerCAmelCase    ) > 0.5
          ).float()
          __UpperCAmelCase			:				int													=    (torch.rand((self.batch_size, self.num_labels)							,				device=_lowerCAmelCase    ) > 0.5).long()

          __UpperCAmelCase			:				Any													=    self.get_config()
          return config, pixel_values, pixel_mask, mask_labels, class_labels

     def 				lowerCamelCase__				(       self  :	Tuple    )		->							Tuple:
          return MaskFormerConfig.from_backbone_and_decoder_configs(
              backbone_config=SwinConfig(
                  depths=[1, 1, 1, 1]							,				)							,				decoder_config=DetrConfig(
                  decoder_ffn_dim=128							,				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 				lowerCamelCase__				(       self  :	Tuple    )		->							int:
          __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase			:				int													=    self.prepare_config_and_inputs()
          __UpperCAmelCase			:				str													=    {'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
          return config, inputs_dict

     def 				lowerCamelCase__				(       self  :	List[Any]							,				snake_case  :	int							,				snake_case  :	Dict    )		->							int:
          __UpperCAmelCase			:				Dict													=    output.encoder_hidden_states
          __UpperCAmelCase			:				List[str]													=    output.pixel_decoder_hidden_states
          __UpperCAmelCase			:				Optional[int]													=    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 				lowerCamelCase__				(       self  :	Optional[Any]							,				snake_case  :	Optional[Any]							,				snake_case  :	Dict							,				snake_case  :	Any							,				snake_case  :	List[Any]=False    )		->							Tuple:







          with torch.no_grad():
               __UpperCAmelCase			:				int													=    MaskFormerModel(config=_lowerCAmelCase    )
               model.to(_lowerCAmelCase    )
               model.eval()

               __UpperCAmelCase			:				Optional[Any]													=    model(pixel_values=_lowerCAmelCase							,				pixel_mask=_lowerCAmelCase    )
               __UpperCAmelCase			:				Dict													=    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 				lowerCamelCase__				(       self  :	Optional[Any]							,				snake_case  :	int							,				snake_case  :	Any							,				snake_case  :	int							,				snake_case  :	Any							,				snake_case  :	int    )		->							int:
          __UpperCAmelCase			:				Optional[Any]													=    MaskFormerForInstanceSegmentation(config=_lowerCAmelCase    )
          model.to(_lowerCAmelCase    )
          model.eval()

          def comm_check_on_output(snake_case  :	List[Any]    ):
               # 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			:				int													=    model(pixel_values=_lowerCAmelCase							,				pixel_mask=_lowerCAmelCase    )
               __UpperCAmelCase			:				Optional[int]													=    model(_lowerCAmelCase    )

               comm_check_on_output(_lowerCAmelCase    )

               __UpperCAmelCase			:				Optional[Any]													=    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       (	_lowerCAmelCase			,						_lowerCAmelCase			,						unittest.TestCase ):


     """simple docstring"""






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

     SCREAMING_SNAKE_CASE :				Tuple							     =     False
     SCREAMING_SNAKE_CASE :				List[str]							     =     False
     SCREAMING_SNAKE_CASE :				List[str]							     =     False
     SCREAMING_SNAKE_CASE :				List[str]							     =     False

     def 				lowerCamelCase__				(       self  :	Dict    )		->							Dict:
          __UpperCAmelCase			:				str													=    MaskFormerModelTester(self    )
          __UpperCAmelCase			:				str													=    ConfigTester(self							,				config_class=_lowerCAmelCase							,				has_text_modality=_lowerCAmelCase    )

     def 				lowerCamelCase__				(       self  :	Tuple    )		->							Optional[Any]:
          self.config_tester.run_common_tests()

     def 				lowerCamelCase__				(       self  :	str    )		->							Optional[Any]:
          __UpperCAmelCase							,     __UpperCAmelCase			:				List[Any]													=    self.model_tester.prepare_config_and_inputs_for_common()
          self.model_tester.create_and_check_maskformer_model(_lowerCAmelCase							,				**_lowerCAmelCase							,				output_hidden_states=_lowerCAmelCase    )

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Union[str, Any]:
          __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 				lowerCamelCase__				(       self  :	List[str]    )		->							Union[str, Any]:
          pass

     @unittest.skip(reason='''MaskFormer does not have a get_input_embeddings method'''    )
     def 				lowerCamelCase__				(       self  :	List[str]    )		->							Dict:
          pass

     @unittest.skip(reason='''MaskFormer is not a generative model'''    )
     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							Optional[int]:
          pass

     @unittest.skip(reason='''MaskFormer does not use token embeddings'''    )
     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							List[str]:
          pass

     @require_torch_multi_gpu
     @unittest.skip(
         reason='''MaskFormer has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''    )
     def 				lowerCamelCase__				(       self  :	Any    )		->							List[Any]:
          pass

     @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''    )
     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							Any:
          pass

     def 				lowerCamelCase__				(       self  :	int    )		->							str:
          __UpperCAmelCase							,     __UpperCAmelCase			:				Optional[int]													=    self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               __UpperCAmelCase			:				List[str]													=    model_class(_lowerCAmelCase    )
               __UpperCAmelCase			:				Tuple													=    inspect.signature(model.forward    )
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               __UpperCAmelCase			:				List[Any]													=    [*signature.parameters.keys()]

               __UpperCAmelCase			:				Any													=    ['''pixel_values''']
               self.assertListEqual(arg_names[:1]							,				_lowerCAmelCase    )

     @slow
     def 				lowerCamelCase__				(       self  :	Any    )		->							Any:







          for model_name in ["facebook/maskformer-swin-small-coco"]:
               __UpperCAmelCase			:				Optional[Any]													=    MaskFormerModel.from_pretrained(_lowerCAmelCase    )
               self.assertIsNotNone(_lowerCAmelCase    )

     def 				lowerCamelCase__				(       self  :	List[str]    )		->							Union[str, Any]:
          __UpperCAmelCase			:				Optional[int]													=    (self.model_tester.min_size,) * 2
          __UpperCAmelCase			:				Any													=    {
              '''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			:				Any													=    MaskFormerForInstanceSegmentation(MaskFormerConfig()    ).to(_lowerCAmelCase    )
          __UpperCAmelCase			:				int													=    model(**_lowerCAmelCase    )
          self.assertTrue(outputs.loss is not None    )

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							str:
          __UpperCAmelCase							,     __UpperCAmelCase			:				Any													=    self.model_tester.prepare_config_and_inputs_for_common()
          self.model_tester.create_and_check_maskformer_model(_lowerCAmelCase							,				**_lowerCAmelCase							,				output_hidden_states=_lowerCAmelCase    )

     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Any:
          __UpperCAmelCase							,     __UpperCAmelCase			:				Optional[Any]													=    self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               __UpperCAmelCase			:				Union[str, Any]													=    model_class(_lowerCAmelCase    ).to(_lowerCAmelCase    )
               __UpperCAmelCase			:				List[str]													=    model(**_lowerCAmelCase							,				output_attentions=_lowerCAmelCase    )
               self.assertTrue(outputs.attentions is not None    )

     def 				lowerCamelCase__				(       self  :	Dict    )		->							Dict:







          if not self.model_tester.is_training:
               return
          # only MaskFormerForInstanceSegmentation has the loss
          __UpperCAmelCase			:				Dict													=    self.all_model_classes[1]
          __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase			:				List[str]													=    self.model_tester.prepare_config_and_inputs()

          __UpperCAmelCase			:				Dict													=    model_class(_lowerCAmelCase    )
          model.to(_lowerCAmelCase    )
          model.train()

          __UpperCAmelCase			:				Optional[Any]													=    model(_lowerCAmelCase							,				mask_labels=_lowerCAmelCase							,				class_labels=_lowerCAmelCase    ).loss
          loss.backward()






     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Union[str, Any]:
          __UpperCAmelCase			:				Optional[int]													=    self.all_model_classes[1]
          __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase							,     __UpperCAmelCase			:				str													=    self.model_tester.prepare_config_and_inputs()
          __UpperCAmelCase			:				str													=    True
          __UpperCAmelCase			:				List[str]													=    True

          __UpperCAmelCase			:				Tuple													=    model_class(_lowerCAmelCase    )
          model.to(_lowerCAmelCase    )
          model.train()

          __UpperCAmelCase			:				List[str]													=    model(_lowerCAmelCase							,				mask_labels=_lowerCAmelCase							,				class_labels=_lowerCAmelCase    )

          __UpperCAmelCase			:				Union[str, Any]													=    outputs.encoder_hidden_states[0]
          encoder_hidden_states.retain_grad()

          __UpperCAmelCase			:				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			:				str													=    outputs.transformer_decoder_hidden_states[0]
          transformer_decoder_hidden_states.retain_grad()

          __UpperCAmelCase			:				int													=    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    :Optional[Any]				       =     1e-4




def 			_a			(		):





     '''simple docstring'''






     __UpperCAmelCase			:				str													=    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
     return image



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


     """simple docstring"""






     @cached_property
     def 				lowerCamelCase__				(       self  :	Dict    )		->							int:
          return (
              MaskFormerImageProcessor.from_pretrained('''facebook/maskformer-swin-small-coco'''    )
              if is_vision_available()
              else None
          )

     def 				lowerCamelCase__				(       self  :	str    )		->							str:
          __UpperCAmelCase			:				int													=    MaskFormerModel.from_pretrained('''facebook/maskformer-swin-small-coco'''    ).to(_lowerCAmelCase    )
          __UpperCAmelCase			:				Optional[Any]													=    self.default_image_processor
          __UpperCAmelCase			:				Optional[Any]													=    prepare_img()
          __UpperCAmelCase			:				Any													=    image_processor(_lowerCAmelCase							,				return_tensors='''pt'''    ).to(_lowerCAmelCase    )
          __UpperCAmelCase			:				int													=    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, 800, 1088)    )

          with torch.no_grad():
               __UpperCAmelCase			:				List[Any]													=    model(**_lowerCAmelCase    )

          __UpperCAmelCase			:				Any													=    torch.tensor(
              [[-0.0_482, 0.9_228, 0.4_951], [-0.2_547, 0.8_017, 0.8_527], [-0.0_069, 0.3_385, -0.0_089]]    ).to(_lowerCAmelCase    )
          self.assertTrue(
              torch.allclose(
                  outputs.encoder_last_hidden_state[0, 0, :3, :3]							,				_lowerCAmelCase							,				atol=_lowerCAmelCase    )    )

          __UpperCAmelCase			:				Optional[Any]													=    torch.tensor(
              [[-0.8_422, -0.8_434, -0.9_718], [-1.0_144, -0.5_565, -0.4_195], [-1.0_038, -0.4_484, -0.1_961]]    ).to(_lowerCAmelCase    )
          self.assertTrue(
              torch.allclose(
                  outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]							,				_lowerCAmelCase							,				atol=_lowerCAmelCase    )    )

          __UpperCAmelCase			:				int													=    torch.tensor(
              [[0.2_852, -0.0_159, 0.9_735], [0.6_254, 0.1_858, 0.8_529], [-0.0_680, -0.4_116, 1.8_413]]    ).to(_lowerCAmelCase    )
          self.assertTrue(
              torch.allclose(
                  outputs.transformer_decoder_last_hidden_state[0, :3, :3]							,				_lowerCAmelCase							,				atol=_lowerCAmelCase    )    )

     def 				lowerCamelCase__				(       self  :	int    )		->							List[str]:
          __UpperCAmelCase			:				Optional[Any]													=    (
              MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco'''    )
              .to(_lowerCAmelCase    )
              .eval()
          )
          __UpperCAmelCase			:				List[Any]													=    self.default_image_processor
          __UpperCAmelCase			:				List[Any]													=    prepare_img()
          __UpperCAmelCase			:				Any													=    image_processor(_lowerCAmelCase							,				return_tensors='''pt'''    ).to(_lowerCAmelCase    )
          __UpperCAmelCase			:				str													=    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, 800, 1088)    )

          with torch.no_grad():
               __UpperCAmelCase			:				Tuple													=    model(**_lowerCAmelCase    )
          # masks_queries_logits
          __UpperCAmelCase			:				List[str]													=    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			:				Optional[Any]													=    [
              [-1.3_737_124, -1.7_724_937, -1.9_364_233],
              [-1.5_977_281, -1.9_867_939, -2.1_523_695],
              [-1.5_795_398, -1.9_269_832, -2.093_942],
          ]
          __UpperCAmelCase			:				str													=    torch.tensor(_lowerCAmelCase    ).to(_lowerCAmelCase    )
          self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]							,				_lowerCAmelCase							,				atol=_lowerCAmelCase    )    )
          # class_queries_logits
          __UpperCAmelCase			:				Optional[int]													=    outputs.class_queries_logits
          self.assertEqual(
              class_queries_logits.shape							,				(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)    )
          __UpperCAmelCase			:				Union[str, 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 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Optional[int]:
          __UpperCAmelCase			:				int													=    (
              MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-resnet101-coco-stuff'''    )
              .to(_lowerCAmelCase    )
              .eval()
          )
          __UpperCAmelCase			:				List[str]													=    self.default_image_processor
          __UpperCAmelCase			:				int													=    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, 800, 1088)    )

          with torch.no_grad():
               __UpperCAmelCase			:				Optional[int]													=    model(**_lowerCAmelCase    )
          # masks_queries_logits
          __UpperCAmelCase			:				Dict													=    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			:				Optional[Any]													=    [[-0.9_046, -2.6_366, -4.6_062], [-3.4_179, -5.7_890, -8.8_057], [-4.9_179, -7.6_560, -10.7_711]]
          __UpperCAmelCase			:				List[Any]													=    torch.tensor(_lowerCAmelCase    ).to(_lowerCAmelCase    )
          self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]							,				_lowerCAmelCase							,				atol=_lowerCAmelCase    )    )
          # class_queries_logits
          __UpperCAmelCase			:				Optional[Any]													=    outputs.class_queries_logits
          self.assertEqual(
              class_queries_logits.shape							,				(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)    )
          __UpperCAmelCase			:				str													=    torch.tensor(
              [[4.7_188, -3.2_585, -2.8_857], [6.6_871, -2.9_181, -1.2_487], [7.2_449, -2.2_764, -2.1_874]]    ).to(_lowerCAmelCase    )
          self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]							,				_lowerCAmelCase							,				atol=_lowerCAmelCase    )    )






     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Optional[Any]:
          __UpperCAmelCase			:				Any													=    (
              MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco'''    )
              .to(_lowerCAmelCase    )
              .eval()
          )
          __UpperCAmelCase			:				List[Any]													=    self.default_image_processor

          __UpperCAmelCase			:				Union[str, Any]													=    image_processor(
              [np.zeros((3, 800, 1333)    ), np.zeros((3, 800, 1333)    )]							,				segmentation_maps=[np.zeros((384, 384)    ).astype(np.floataa    ), np.zeros((384, 384)    ).astype(np.floataa    )]							,				return_tensors='''pt'''							,				)

          __UpperCAmelCase			:				List[Any]													=    inputs['''pixel_values'''].to(_lowerCAmelCase    )
          __UpperCAmelCase			:				int													=    [el.to(_lowerCAmelCase    ) for el in inputs['''mask_labels''']]
          __UpperCAmelCase			:				Optional[Any]													=    [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    )



'''simple docstring'''



import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch



class 			a       (	unittest.TestCase ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE :				Any							     =     JukeboxTokenizer
     SCREAMING_SNAKE_CASE :				Tuple							     =     {
         "artist": "Zac Brown Band",
         "genres": "Country",
         "lyrics": "I met a traveller from an antique land,\n        Who said \"Two vast and trunkless legs of stone\n        Stand in the desert. . . . Near them, on the sand,\n        Half sunk a shattered visage lies, whose frown,\n        And wrinkled lip, and sneer of cold command,\n        Tell that its sculptor well those passions read\n        Which yet survive, stamped on these lifeless things,\n        The hand that mocked them, and the heart that fed;\n        And on the pedestal, these words appear:\n        My name is Ozymandias, King of Kings;\n        Look on my Works, ye Mighty, and despair!\n        Nothing beside remains. Round the decay\n        Of that colossal Wreck, boundless and bare\n        The lone and level sands stretch far away\n        ",
     }

     @require_torch
     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							Optional[Any]:
          import torch

          __UpperCAmelCase			:				List[str]													=    JukeboxTokenizer.from_pretrained('''openai/jukebox-1b-lyrics'''    )
          __UpperCAmelCase			:				int													=    tokenizer(**self.metas    )['''input_ids''']
          # fmt: off
          __UpperCAmelCase			:				List[str]													=    [
              torch.tensor([[
                  0, 0, 0, 7169, 507, 9, 76, 39, 31, 46, 76, 27,
                  76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32,
                  44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43,
                  47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76,
                  76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35,
                  30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76,
                  27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45,
                  45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46,
                  41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
                  19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31,
                  76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63,
                  76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39,
                  64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40,
                  30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8,
                  27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45,
                  34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45,
                  27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34,
                  41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76,
                  76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49,
                  44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64,
                  76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41,
                  32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27,
                  40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76,
                  20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46,
                  45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49,
                  31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27,
                  45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78,
                  76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29,
                  34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48,
                  31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41,
                  40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31,
                  38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64,
                  78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31,
                  76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39,
                  41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76,
                  27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44,
                  46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78,
                  76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76,
                  41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45,
                  46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49,
                  41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65,
                  78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76,
                  40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39,
                  27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33,
                  76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76,
                  76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76,
                  41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64,
                  76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76,
                  27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67,
                  78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46,
                  34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76,
                  44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47,
                  40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51,
                  78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76,
                  46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27,
                  38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47,
                  40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28,
                  27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
                  20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30,
                  76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45,
                  76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44,
                  76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76,
                  76, 76]]    ),
              torch.tensor([[0, 0, 0, 1069, 11]]    ),
              torch.tensor([[0, 0, 0, 1069, 11]]    ),
          ]
          # fmt: on
          self.assertTrue(torch.allclose(tokens[0]							,				EXPECTED_OUTPUT[0]    )    )
          self.assertTrue(torch.allclose(tokens[1]							,				EXPECTED_OUTPUT[1]    )    )
          self.assertTrue(torch.allclose(tokens[2]							,				EXPECTED_OUTPUT[2]    )    )






     @require_torch
     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Union[str, Any]:
          import torch

          __UpperCAmelCase			:				Optional[int]													=    JukeboxTokenizer.from_pretrained('''openai/jukebox-5b-lyrics'''    )
          __UpperCAmelCase			:				List[Any]													=    tokenizer(**self.metas    )['''input_ids''']
          # fmt: off
          __UpperCAmelCase			:				List[str]													=    [
              torch.tensor([[
                  0, 0, 0, 1069, 11, -1, -1, -1, -1, 9, 77, 39,
                  31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38,
                  31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27,
                  40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64,
                  79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41,
                  77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48,
                  27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40,
                  37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41,
                  32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77,
                  77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40,
                  77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63,
                  77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77,
                  46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31,
                  77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77,
                  77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37,
                  77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30,
                  77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45,
                  64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49,
                  40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1,
                  40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77,
                  38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31,
                  31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29,
                  41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77,
                  77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27,
                  46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46,
                  41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45,
                  31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44,
                  31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77,
                  23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47,
                  44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42,
                  31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77,
                  38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35,
                  40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77,
                  77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34,
                  27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34,
                  31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77,
                  34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32,
                  31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77,
                  1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42,
                  31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31,
                  45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42,
                  31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77,
                  77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77,
                  15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77,
                  11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33,
                  45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12,
                  41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41,
                  44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34,
                  46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42,
                  27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77,
                  77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45,
                  35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63,
                  77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30,
                  31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77,
                  77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38,
                  41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64,
                  77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27,
                  40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77,
                  77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31,
                  77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45,
                  27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34,
                  77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77,
                  77, 77, 77, 77, 77, 77]]    ),
              torch.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]    ),
              torch.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]    ),
          ]
          # fmt: on
          self.assertTrue(torch.allclose(tokens[0]							,				EXPECTED_OUTPUT[0]    )    )
          self.assertTrue(torch.allclose(tokens[1]							,				EXPECTED_OUTPUT[1]    )    )
          self.assertTrue(torch.allclose(tokens[2]							,				EXPECTED_OUTPUT[2]    )    )