




import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


lowerCamelCase__			:       Tuple         =							get_tests_dir('fixtures/test_sentencepiece.model')

if is_torch_available():
   from transformers.models.mbart.modeling_mbart import shift_tokens_right

lowerCamelCase__			:       Tuple         =							250_004
lowerCamelCase__			:       Dict         =							250_020





@require_sentencepiece
@require_tokenizers
class 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE	,       unittest.TestCase ):


 '''simple docstring'''







 lowercase_       =   MBartaaTokenizer
 lowercase_       =   MBartaaTokenizerFast
 lowercase_       =   True
 lowercase_       =   True



 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       super().setUp()

       # We have a SentencePiece fixture for testing
       SCREAMING_SNAKE_CASE_     						=      MBartaaTokenizer(_lowerCAmelCase    ,    src_lang='en_XX'    ,    tgt_lang='ro_RO'    ,    keep_accents=_lowerCAmelCase						)
       tokenizer.save_pretrained(self.tmpdirname						)



 def 				lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_     						=      '<s>'
       SCREAMING_SNAKE_CASE_     						=      0

       self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowerCAmelCase						)    ,    _lowerCAmelCase						)
       self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowerCAmelCase						)    ,    _lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_     						=      list(self.get_tokenizer().get_vocab().keys()						)

       self.assertEqual(vocab_keys[0]    ,    '<s>'						)
       self.assertEqual(vocab_keys[1]    ,    '<pad>'						)
       self.assertEqual(vocab_keys[-1]    ,    '<mask>'						)
       self.assertEqual(len(_lowerCAmelCase						)    ,    1_054						)



 def 				lowerCAmelCase_  (							self  :		Dict						):
       self.assertEqual(self.get_tokenizer().vocab_size    ,    1_054						)



 def 				lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_     						=      MBartaaTokenizer(_lowerCAmelCase    ,    src_lang='en_XX'    ,    tgt_lang='ro_RO'    ,    keep_accents=_lowerCAmelCase						)

       SCREAMING_SNAKE_CASE_     						=      tokenizer.tokenize('This is a test'						)
       self.assertListEqual(_lowerCAmelCase    ,    ['▁This', '▁is', '▁a', '▁t', 'est']						)

       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(_lowerCAmelCase						)    ,    [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]    ,    )

       SCREAMING_SNAKE_CASE_     						=      tokenizer.tokenize('I was born in 92000, and this is falsé.'						)
       self.assertListEqual(
           _lowerCAmelCase    ,    [SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', 'é', '.']    ,    )
       SCREAMING_SNAKE_CASE_     						=      tokenizer.convert_tokens_to_ids(_lowerCAmelCase						)
       self.assertListEqual(
           _lowerCAmelCase    ,    [
               value + tokenizer.fairseq_offset
               for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
           ]    ,    )

       SCREAMING_SNAKE_CASE_     						=      tokenizer.convert_ids_to_tokens(_lowerCAmelCase						)
       self.assertListEqual(
           _lowerCAmelCase    ,    [SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.']    ,    )



 @slow
 def 				lowerCAmelCase_  (							self  :		str						):
       # fmt: off
       SCREAMING_SNAKE_CASE_     						=      {'input_ids': [[250_004, 11_062, 82_772, 7, 15, 82_772, 538, 51_529, 237, 17_198, 1_290, 206, 9, 215_175, 1_314, 136, 17_198, 1_290, 206, 9, 56_359, 42, 122_009, 9, 16_466, 16, 87_344, 4_537, 9, 4_717, 78_381, 6, 159_958, 7, 15, 24_480, 618, 4, 527, 22_693, 5_428, 4, 2_777, 24_480, 9_874, 4, 43_523, 594, 4, 803, 18_392, 33_189, 18, 4, 43_523, 24_447, 12_399, 100, 24_955, 83_658, 9_626, 144_057, 15, 839, 22_335, 16, 136, 24_955, 83_658, 83_479, 15, 39_102, 724, 16, 678, 645, 2_789, 1_328, 4_589, 42, 122_009, 115_774, 23, 805, 1_328, 46_876, 7, 136, 53_894, 1_940, 42_227, 41_159, 17_721, 823, 425, 4, 27_512, 98_722, 206, 136, 5_531, 4_970, 919, 17_336, 5, 2], [250_004, 20_080, 618, 83, 82_775, 47, 479, 9, 1_517, 73, 53_894, 333, 80_581, 110_117, 18_811, 5_256, 1_295, 51, 152_526, 297, 7_986, 390, 124_416, 538, 35_431, 214, 98, 15_044, 25_737, 136, 7_108, 43_701, 23, 756, 135_355, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [250_004, 581, 63_773, 119_455, 6, 147_797, 88_203, 7, 645, 70, 21, 3_285, 10_269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
       # fmt: on

       self.tokenizer_integration_test_util(
           expected_encoding=_lowerCAmelCase    ,    model_name='facebook/mbart-large-50'    ,    revision='d3913889c59cd5c9e456b269c376325eabad57e2'    ,    )




 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       if not self.test_slow_tokenizer:
             # as we don't have a slow version, we can't compare the outputs between slow and fast versions
             return

       SCREAMING_SNAKE_CASE_     						=      (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-mbart50', {})
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"						):
                   SCREAMING_SNAKE_CASE_     						=      self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase    ,    **_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      self.tokenizer_class.from_pretrained(_lowerCAmelCase    ,    **_lowerCAmelCase						)

                   SCREAMING_SNAKE_CASE_     						=      tempfile.mkdtemp()

                   SCREAMING_SNAKE_CASE_     						=      tokenizer_r.save_pretrained(_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_p.save_pretrained(_lowerCAmelCase						)

                   # Checks it save with the same files + the tokenizer.json file for the fast one
                   self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files						)						)
                   SCREAMING_SNAKE_CASE_     						=      tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f						)
                   self.assertSequenceEqual(_lowerCAmelCase    ,    _lowerCAmelCase						)

                   # Checks everything loads correctly in the same way
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_r.from_pretrained(_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_p.from_pretrained(_lowerCAmelCase						)

                   # Check special tokens are set accordingly on Rust and Python
                   for key in tokenizer_pp.special_tokens_map:
                         self.assertTrue(hasattr(_lowerCAmelCase    ,    _lowerCAmelCase						)						)
                         # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                         # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                   shutil.rmtree(_lowerCAmelCase						)

                   # Save tokenizer rust, legacy_format=True
                   SCREAMING_SNAKE_CASE_     						=      tempfile.mkdtemp()

                   SCREAMING_SNAKE_CASE_     						=      tokenizer_r.save_pretrained(_lowerCAmelCase    ,    legacy_format=_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_p.save_pretrained(_lowerCAmelCase						)

                   # Checks it save with the same files
                   self.assertSequenceEqual(_lowerCAmelCase    ,    _lowerCAmelCase						)

                   # Checks everything loads correctly in the same way
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_r.from_pretrained(_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_p.from_pretrained(_lowerCAmelCase						)

                   # Check special tokens are set accordingly on Rust and Python
                   for key in tokenizer_pp.special_tokens_map:
                         self.assertTrue(hasattr(_lowerCAmelCase    ,    _lowerCAmelCase						)						)

                   shutil.rmtree(_lowerCAmelCase						)

                   # Save tokenizer rust, legacy_format=False
                   SCREAMING_SNAKE_CASE_     						=      tempfile.mkdtemp()

                   SCREAMING_SNAKE_CASE_     						=      tokenizer_r.save_pretrained(_lowerCAmelCase    ,    legacy_format=_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_p.save_pretrained(_lowerCAmelCase						)

                   # Checks it saved the tokenizer.json file
                   self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files						)						)

                   # Checks everything loads correctly in the same way
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_r.from_pretrained(_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_p.from_pretrained(_lowerCAmelCase						)

                   # Check special tokens are set accordingly on Rust and Python
                   for key in tokenizer_pp.special_tokens_map:
                         self.assertTrue(hasattr(_lowerCAmelCase    ,    _lowerCAmelCase						)						)

                   shutil.rmtree(_lowerCAmelCase						)





@require_torch
@require_sentencepiece
@require_tokenizers
class 	lowerCamelCase_							(				unittest.TestCase ):


 '''simple docstring'''







 lowercase_       =   "facebook/mbart-large-50-one-to-many-mmt"
 lowercase_       =   [
     " UN Chief Says There Is No Military Solution in Syria",
     " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
 ]
 lowercase_       =   [
     "Şeful ONU declară că nu există o soluţie militară în Siria",
     "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
     " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
     " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
 ]
 lowercase_       =   [EN_CODE, 8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2]



 @classmethod
 def 				lowerCAmelCase_  (							cls  :		int						):
       SCREAMING_SNAKE_CASE_     						=      MBartaaTokenizer.from_pretrained(
           cls.checkpoint_name    ,    src_lang='en_XX'    ,    tgt_lang='ro_RO'						)
       SCREAMING_SNAKE_CASE_     						=      1
       return cls



 def 				lowerCAmelCase_  (							self  :		Any						):
       self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ar_AR']    ,    250_001						)
       self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['en_EN']    ,    250_004						)
       self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ro_RO']    ,    250_020						)
       self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['mr_IN']    ,    250_038						)



 def 				lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer.batch_encode_plus(self.src_text						).input_ids[0]
       self.assertListEqual(self.expected_src_tokens    ,    _lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		str						):
       self.assertIn(_lowerCAmelCase    ,    self.tokenizer.all_special_ids						)
       SCREAMING_SNAKE_CASE_     						=      [RO_CODE, 884, 9_019, 96, 9, 916, 86_792, 36, 18_743, 15_596, 5, 2]
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer.decode(_lowerCAmelCase    ,    skip_special_tokens=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer.decode(generated_ids[1:]    ,    skip_special_tokens=_lowerCAmelCase						)
       self.assertEqual(_lowerCAmelCase    ,    _lowerCAmelCase						)
       self.assertNotIn(self.tokenizer.eos_token    ,    _lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_     						=      ['this is gunna be a long sentence ' * 20]
       assert isinstance(src_text[0]    ,    _lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      10
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer(_lowerCAmelCase    ,    max_length=_lowerCAmelCase    ,    truncation=_lowerCAmelCase						).input_ids[0]
       self.assertEqual(ids[0]    ,    _lowerCAmelCase						)
       self.assertEqual(ids[-1]    ,    2						)
       self.assertEqual(len(_lowerCAmelCase						)    ,    _lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Optional[Any]						):
       self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']						)    ,    [250_053, 250_001]						)



 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_     						=      tempfile.mkdtemp()
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer.fairseq_tokens_to_ids
       self.tokenizer.save_pretrained(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      MBartaaTokenizer.from_pretrained(_lowerCAmelCase						)
       self.assertDictEqual(new_tok.fairseq_tokens_to_ids    ,    _lowerCAmelCase						)



 @require_torch
 def 				lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer(self.src_text    ,    text_target=self.tgt_text    ,    padding=_lowerCAmelCase    ,    return_tensors='pt'						)
       SCREAMING_SNAKE_CASE_     						=      shift_tokens_right(batch['labels']    ,    self.tokenizer.pad_token_id						)

       # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
       assert batch.input_ids[1][0] == EN_CODE
       assert batch.input_ids[1][-1] == 2
       assert batch.labels[1][0] == RO_CODE
       assert batch.labels[1][-1] == 2
       assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]



 @require_torch
 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer(
           self.src_text    ,    text_target=self.tgt_text    ,    padding=_lowerCAmelCase    ,    truncation=_lowerCAmelCase    ,    max_length=len(self.expected_src_tokens						)    ,    return_tensors='pt'    ,    )
       SCREAMING_SNAKE_CASE_     						=      shift_tokens_right(batch['labels']    ,    self.tokenizer.pad_token_id						)

       self.assertIsInstance(_lowerCAmelCase    ,    _lowerCAmelCase						)

       self.assertEqual((2, 14)    ,    batch.input_ids.shape						)
       self.assertEqual((2, 14)    ,    batch.attention_mask.shape						)
       SCREAMING_SNAKE_CASE_     						=      batch.input_ids.tolist()[0]
       self.assertListEqual(self.expected_src_tokens    ,    _lowerCAmelCase						)
       self.assertEqual(2    ,    batch.decoder_input_ids[0, 0]						)  # decoder_start_token_id
       # Test that special tokens are reset
       self.assertEqual(self.tokenizer.prefix_tokens    ,    [EN_CODE]						)
       self.assertEqual(self.tokenizer.suffix_tokens    ,    [self.tokenizer.eos_token_id]						)



 def 				lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer(self.src_text    ,    padding=_lowerCAmelCase    ,    truncation=_lowerCAmelCase    ,    max_length=3    ,    return_tensors='pt'						)
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer(
           text_target=self.tgt_text    ,    padding=_lowerCAmelCase    ,    truncation=_lowerCAmelCase    ,    max_length=10    ,    return_tensors='pt'						)
       SCREAMING_SNAKE_CASE_     						=      targets['input_ids']
       SCREAMING_SNAKE_CASE_     						=      shift_tokens_right(_lowerCAmelCase    ,    self.tokenizer.pad_token_id						)

       self.assertEqual(batch.input_ids.shape[1]    ,    3						)
       self.assertEqual(batch.decoder_input_ids.shape[1]    ,    10						)




 @require_torch
 def 				lowerCAmelCase_  (							self  :		Dict						):
       SCREAMING_SNAKE_CASE_     						=      self.tokenizer._build_translation_inputs(
           'A test'    ,    return_tensors='pt'    ,    src_lang='en_XX'    ,    tgt_lang='ar_AR'						)

       self.assertEqual(
           nested_simplify(_lowerCAmelCase						)    ,    {
               # en_XX, A, test, EOS
               'input_ids': [[250_004, 62, 3_034, 2]],
               'attention_mask': [[1, 1, 1, 1]],
               # ar_AR
               'forced_bos_token_id': 250_001,
           }    ,    )





import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, 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 MaskaFormerForUniversalSegmentation, MaskaFormerModel

   if is_vision_available():
      from transformers import MaskaFormerImageProcessor

if is_vision_available():
   from PIL import Image





class 	lowerCamelCase_							:


 '''simple docstring'''







 def __init__(							self  :		Any    ,    _lowerCAmelCase  :		Optional[Any]    ,    _lowerCAmelCase  :		List[Any]=2    ,    _lowerCAmelCase  :		List[str]=True    ,    _lowerCAmelCase  :		Any=False    ,    _lowerCAmelCase  :		Tuple=10    ,    _lowerCAmelCase  :		Optional[int]=3    ,    _lowerCAmelCase  :		Dict=32 * 8    ,    _lowerCAmelCase  :		List[str]=32 * 8    ,    _lowerCAmelCase  :		List[Any]=4    ,    _lowerCAmelCase  :		Optional[Any]=64    ,    ):
       SCREAMING_SNAKE_CASE_     						=      parent
       SCREAMING_SNAKE_CASE_     						=      batch_size
       SCREAMING_SNAKE_CASE_     						=      is_training
       SCREAMING_SNAKE_CASE_     						=      use_auxiliary_loss
       SCREAMING_SNAKE_CASE_     						=      num_queries
       SCREAMING_SNAKE_CASE_     						=      num_channels
       SCREAMING_SNAKE_CASE_     						=      min_size
       SCREAMING_SNAKE_CASE_     						=      max_size
       SCREAMING_SNAKE_CASE_     						=      num_labels
       SCREAMING_SNAKE_CASE_     						=      hidden_dim
       SCREAMING_SNAKE_CASE_     						=      hidden_dim



 def 				lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_     						=      floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]						).to(
           _lowerCAmelCase						)

       SCREAMING_SNAKE_CASE_     						=      torch.ones([self.batch_size, self.min_size, self.max_size]    ,    device=_lowerCAmelCase						)

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

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



 def 				lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_     						=      MaskaFormerConfig(
           hidden_size=self.hidden_dim    ,    )
       SCREAMING_SNAKE_CASE_     						=      self.num_queries
       SCREAMING_SNAKE_CASE_     						=      self.num_labels

       SCREAMING_SNAKE_CASE_     						=      [1, 1, 1, 1]
       SCREAMING_SNAKE_CASE_     						=      self.num_channels

       SCREAMING_SNAKE_CASE_     						=      64
       SCREAMING_SNAKE_CASE_     						=      128
       SCREAMING_SNAKE_CASE_     						=      self.hidden_dim
       SCREAMING_SNAKE_CASE_     						=      self.hidden_dim
       SCREAMING_SNAKE_CASE_     						=      self.hidden_dim
       return config



 def 				lowerCAmelCase_  (							self  :		Optional[int]						):
       SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE_     						=      {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
       return config, inputs_dict



 def 				lowerCAmelCase_  (							self  :		Optional[Any]    ,    _lowerCAmelCase  :		Union[str, Any]    ,    _lowerCAmelCase  :		Tuple						):
       SCREAMING_SNAKE_CASE_     						=      output.encoder_hidden_states
       SCREAMING_SNAKE_CASE_     						=      output.pixel_decoder_hidden_states
       SCREAMING_SNAKE_CASE_     						=      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_layers						)



 def 				lowerCAmelCase_  (							self  :		Optional[Any]    ,    _lowerCAmelCase  :		Tuple    ,    _lowerCAmelCase  :		Tuple    ,    _lowerCAmelCase  :		Any    ,    _lowerCAmelCase  :		Any=False						):
       with torch.no_grad():
             SCREAMING_SNAKE_CASE_     						=      MaskaFormerModel(config=_lowerCAmelCase						)
             model.to(_lowerCAmelCase						)
             model.eval()

             SCREAMING_SNAKE_CASE_     						=      model(pixel_values=_lowerCAmelCase    ,    pixel_mask=_lowerCAmelCase						)
             SCREAMING_SNAKE_CASE_     						=      model(_lowerCAmelCase    ,    output_hidden_states=_lowerCAmelCase						)

       self.parent.assertEqual(
           output.transformer_decoder_last_hidden_state.shape    ,    (self.batch_size, self.num_queries, self.hidden_dim)    ,    )
       # 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  :		str    ,    _lowerCAmelCase  :		Dict    ,    _lowerCAmelCase  :		Optional[Any]    ,    _lowerCAmelCase  :		Any    ,    _lowerCAmelCase  :		str    ,    _lowerCAmelCase  :		Any						):
       SCREAMING_SNAKE_CASE_     						=      MaskaFormerForUniversalSegmentation(config=_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()

       def comm_check_on_output(_lowerCAmelCase  :		List[str]						):
             # 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():
             SCREAMING_SNAKE_CASE_     						=      model(pixel_values=_lowerCAmelCase    ,    pixel_mask=_lowerCAmelCase						)
             SCREAMING_SNAKE_CASE_     						=      model(_lowerCAmelCase						)

             comm_check_on_output(_lowerCAmelCase						)

             SCREAMING_SNAKE_CASE_     						=      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 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE	,       _SCREAMING_SNAKE_CASE	,       unittest.TestCase ):


 '''simple docstring'''







 lowercase_       =   (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
 lowercase_       =   {"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

 lowercase_       =   False
 lowercase_       =   False
 lowercase_       =   False
 lowercase_       =   False



 def 				lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_     						=      MaskaFormerModelTester(self						)
       SCREAMING_SNAKE_CASE_     						=      ConfigTester(self    ,    config_class=_lowerCAmelCase    ,    has_text_modality=_lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       self.config_tester.run_common_tests()



 def 				lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskaformer_model(_lowerCAmelCase    ,    **_lowerCAmelCase    ,    output_hidden_states=_lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_     						=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_lowerCAmelCase						)



 @unittest.skip(reason='Mask2Former does not use inputs_embeds'						)
 def 				lowerCAmelCase_  (							self  :		Optional[int]						):
       pass



 @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method'						)
 def 				lowerCAmelCase_  (							self  :		Tuple						):
       pass



 @unittest.skip(reason='Mask2Former is not a generative model'						)
 def 				lowerCAmelCase_  (							self  :		List[Any]						):
       pass



 @unittest.skip(reason='Mask2Former does not use token embeddings'						)
 def 				lowerCAmelCase_  (							self  :		Tuple						):
       pass



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



 @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'						)
 def 				lowerCAmelCase_  (							self  :		int						):
       pass



 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      self.model_tester.prepare_config_and_inputs_for_common()

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

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



 @slow
 def 				lowerCAmelCase_  (							self  :		Any						):
       for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
             SCREAMING_SNAKE_CASE_     						=      MaskaFormerModel.from_pretrained(_lowerCAmelCase						)
             self.assertIsNotNone(_lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_     						=      (self.model_tester.min_size,) * 2
       SCREAMING_SNAKE_CASE_     						=      {
           '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(),
       }
       SCREAMING_SNAKE_CASE_     						=      self.model_tester.get_config()

       SCREAMING_SNAKE_CASE_     						=      MaskaFormerForUniversalSegmentation(_lowerCAmelCase						).to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      model(**_lowerCAmelCase						)
       self.assertTrue(outputs.loss is not None						)



 def 				lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskaformer_model(_lowerCAmelCase    ,    **_lowerCAmelCase    ,    output_hidden_states=_lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      self.model_tester.prepare_config_and_inputs_for_common()

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



 def 				lowerCAmelCase_  (							self  :		List[str]						):
       if not self.model_tester.is_training:
             return

       SCREAMING_SNAKE_CASE_     						=      self.all_model_classes[1]
       SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      self.model_tester.prepare_config_and_inputs()

       SCREAMING_SNAKE_CASE_     						=      model_class(_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.train()

       SCREAMING_SNAKE_CASE_     						=      model(_lowerCAmelCase    ,    mask_labels=_lowerCAmelCase    ,    class_labels=_lowerCAmelCase						).loss
       loss.backward()




 def 				lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_     						=      self.all_model_classes[1]
       SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      self.model_tester.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE_     						=      True
       SCREAMING_SNAKE_CASE_     						=      True

       SCREAMING_SNAKE_CASE_     						=      model_class(_lowerCAmelCase						).to(_lowerCAmelCase						)
       model.train()

       SCREAMING_SNAKE_CASE_     						=      model(_lowerCAmelCase    ,    mask_labels=_lowerCAmelCase    ,    class_labels=_lowerCAmelCase						)

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

       SCREAMING_SNAKE_CASE_     						=      outputs.pixel_decoder_hidden_states[0]
       pixel_decoder_hidden_states.retain_grad()

       SCREAMING_SNAKE_CASE_     						=      outputs.transformer_decoder_hidden_states[0]
       transformer_decoder_hidden_states.retain_grad()

       SCREAMING_SNAKE_CASE_     						=      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						)


lowerCamelCase__			:       Tuple         =							1E-4

def  UpperCAmelCase_							(				) ->			List[Any]:
      SCREAMING_SNAKE_CASE_     						=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
      return image





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


 '''simple docstring'''







 @cached_property
 def 				lowerCAmelCase_  (							self  :		Optional[int]						):
       return "facebook/mask2former-swin-small-coco-instance"



 @cached_property
 def 				lowerCAmelCase_  (							self  :		int						):
       return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints						) if is_vision_available() else None



 def 				lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_     						=      MaskaFormerModel.from_pretrained(self.model_checkpoints						).to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      self.default_image_processor
       SCREAMING_SNAKE_CASE_     						=      prepare_img()
       SCREAMING_SNAKE_CASE_     						=      image_processor(_lowerCAmelCase    ,    return_tensors='pt'						).to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      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, 384, 384)						)

       with torch.no_grad():
             SCREAMING_SNAKE_CASE_     						=      model(**_lowerCAmelCase						)

       SCREAMING_SNAKE_CASE_     						=      torch.tensor(
           [[-0.2790, -1.0717, -1.1668], [-0.5128, -0.3128, -0.4987], [-0.5832, 0.1971, -0.0197]]						).to(_lowerCAmelCase						)
       self.assertTrue(
           torch.allclose(
               outputs.encoder_last_hidden_state[0, 0, :3, :3]    ,    _lowerCAmelCase    ,    atol=_lowerCAmelCase						)						)

       SCREAMING_SNAKE_CASE_     						=      torch.tensor(
           [[0.8973, 1.1847, 1.1776], [1.1934, 1.5040, 1.5128], [1.1153, 1.4486, 1.4951]]						).to(_lowerCAmelCase						)
       self.assertTrue(
           torch.allclose(
               outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]    ,    _lowerCAmelCase    ,    atol=_lowerCAmelCase						)						)

       SCREAMING_SNAKE_CASE_     						=      torch.tensor(
           [[2.1152, 1.7000, -0.8603], [1.5808, 1.8004, -0.9353], [1.6043, 1.7495, -0.5999]]						).to(_lowerCAmelCase						)
       self.assertTrue(
           torch.allclose(
               outputs.transformer_decoder_last_hidden_state[0, :3, :3]    ,    _lowerCAmelCase    ,    atol=_lowerCAmelCase						)						)



 def 				lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_     						=      MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints						).to(_lowerCAmelCase						).eval()
       SCREAMING_SNAKE_CASE_     						=      self.default_image_processor
       SCREAMING_SNAKE_CASE_     						=      prepare_img()
       SCREAMING_SNAKE_CASE_     						=      image_processor(_lowerCAmelCase    ,    return_tensors='pt'						).to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      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, 384, 384)						)

       with torch.no_grad():
             SCREAMING_SNAKE_CASE_     						=      model(**_lowerCAmelCase						)
       # masks_queries_logits
       SCREAMING_SNAKE_CASE_     						=      outputs.masks_queries_logits
       self.assertEqual(
           masks_queries_logits.shape    ,    (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)						)
       SCREAMING_SNAKE_CASE_     						=      [
           [-8.7839, -9.0056, -8.8121],
           [-7.4104, -7.0313, -6.5401],
           [-6.6105, -6.3427, -6.4675],
       ]
       SCREAMING_SNAKE_CASE_     						=      torch.tensor(_lowerCAmelCase						).to(_lowerCAmelCase						)
       self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]    ,    _lowerCAmelCase    ,    atol=_lowerCAmelCase						)						)
       # class_queries_logits
       SCREAMING_SNAKE_CASE_     						=      outputs.class_queries_logits
       self.assertEqual(class_queries_logits.shape    ,    (1, model.config.num_queries, model.config.num_labels + 1)						)
       SCREAMING_SNAKE_CASE_     						=      torch.tensor(
           [
               [1.8324, -8.0835, -4.1922],
               [0.8450, -9.0050, -3.6053],
               [0.3045, -7.7293, -3.0275],
           ]						).to(_lowerCAmelCase						)
       self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]    ,    _lowerCAmelCase    ,    atol=_lowerCAmelCase						)						)




 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_     						=      MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints						).to(_lowerCAmelCase						).eval()
       SCREAMING_SNAKE_CASE_     						=      self.default_image_processor

       SCREAMING_SNAKE_CASE_     						=      image_processor(
           [np.zeros((3, 800, 1_333)						), np.zeros((3, 800, 1_333)						)]    ,    segmentation_maps=[np.zeros((384, 384)						).astype(np.floataa						), np.zeros((384, 384)						).astype(np.floataa						)]    ,    return_tensors='pt'    ,    )

       SCREAMING_SNAKE_CASE_     						=      inputs['pixel_values'].to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      [el.to(_lowerCAmelCase						) for el in inputs['mask_labels']]
       SCREAMING_SNAKE_CASE_     						=      [el.to(_lowerCAmelCase						) for el in inputs['class_labels']]

       with torch.no_grad():
             SCREAMING_SNAKE_CASE_     						=      model(**_lowerCAmelCase						)

       self.assertTrue(outputs.loss is not None						)