




import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


lowercase__				:     Dict 		=						get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
		from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

lowercase__				:     Union[str, Any] 		=						25_6047
lowercase__				:     str 		=						25_6145
@require_sentencepiece
@require_tokenizers
class 		UpperCAmelCase   (				_a       ,   unittest.TestCase			):







						'''simple docstring'''





						lowerCAmelCase_     		=   NllbTokenizer
						lowerCAmelCase_     		=   NllbTokenizerFast
						lowerCAmelCase_     		=   True
						lowerCAmelCase_     		=   True
						lowerCAmelCase_     		=   {}






						def        snake_case__						(						self							:     Optional[int]						):






							"""simple docstring"""






							super().setUp()

							# We have a SentencePiece fixture for testing
							snake_case_		    =     NllbTokenizer(__lowercase       ,	keep_accents=__lowercase						)
							tokenizer.save_pretrained(self.tmpdirname						)






						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							snake_case_		    =     NllbTokenizer(__lowercase       ,	keep_accents=__lowercase						)

							snake_case_		    =     tokenizer.tokenize("This is a test"						)
							self.assertListEqual(__lowercase       ,	["▁This", "▁is", "▁a", "▁t", "est"]						)

							self.assertListEqual(
							    tokenizer.convert_tokens_to_ids(__lowercase						)       ,	[value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]       ,	)

							snake_case_		    =     tokenizer.tokenize("I was born in 92000, and this is falsé."						)
							self.assertListEqual(
							    __lowercase       ,	[
							        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",
							        "é",
							        ".",
							    ]       ,	)
							snake_case_		    =     tokenizer.convert_tokens_to_ids(__lowercase						)
							self.assertListEqual(
							    __lowercase       ,	[
							        value + tokenizer.fairseq_offset
							        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
							    ]       ,	)

							snake_case_		    =     tokenizer.convert_ids_to_tokens(__lowercase						)
							self.assertListEqual(
							    __lowercase       ,	[
							        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>",
							        ".",
							    ]       ,	)






						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






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

									snake_case_		    =     tempfile.mkdtemp()

									snake_case_		    =     tokenizer_r.save_pretrained(__lowercase						)
									snake_case_		    =     tokenizer_p.save_pretrained(__lowercase						)

									# 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						)						)
									snake_case_		    =     tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f						)
									self.assertSequenceEqual(__lowercase       ,	__lowercase						)

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

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

									shutil.rmtree(__lowercase						)

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

									snake_case_		    =     tokenizer_r.save_pretrained(__lowercase       ,	legacy_format=__lowercase						)
									snake_case_		    =     tokenizer_p.save_pretrained(__lowercase						)

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

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

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

									shutil.rmtree(__lowercase						)

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

									snake_case_		    =     tokenizer_r.save_pretrained(__lowercase       ,	legacy_format=__lowercase						)
									snake_case_		    =     tokenizer_p.save_pretrained(__lowercase						)

									# 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
									snake_case_		    =     tokenizer_r.from_pretrained(__lowercase						)
									snake_case_		    =     tokenizer_p.from_pretrained(__lowercase						)

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

									shutil.rmtree(__lowercase						)






						@require_torch
						def        snake_case__						(						self							:     int						):






							"""simple docstring"""






							if not self.test_seqaseq:
								return

							snake_case_		    =     self.get_tokenizers()
							for tokenizer in tokenizers:
								with self.subTest(f"{tokenizer.__class__.__name__}"						):
									# Longer text that will definitely require truncation.
									snake_case_		    =     [
									    ' 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.',
									]
									snake_case_		    =     [
									    'Ş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.',
									]
									try:
										snake_case_		    =     tokenizer.prepare_seqaseq_batch(
										    src_texts=__lowercase       ,	tgt_texts=__lowercase       ,	max_length=3       ,	max_target_length=10       ,	return_tensors="pt"       ,	src_lang="eng_Latn"       ,	tgt_lang="ron_Latn"       ,	)
									except NotImplementedError:
										return
									self.assertEqual(batch.input_ids.shape[1]       ,	3						)
									self.assertEqual(batch.labels.shape[1]       ,	10						)
									# max_target_length will default to max_length if not specified
									snake_case_		    =     tokenizer.prepare_seqaseq_batch(
									    __lowercase       ,	tgt_texts=__lowercase       ,	max_length=3       ,	return_tensors="pt"						)
									self.assertEqual(batch.input_ids.shape[1]       ,	3						)
									self.assertEqual(batch.labels.shape[1]       ,	3						)

									snake_case_		    =     tokenizer.prepare_seqaseq_batch(
									    src_texts=__lowercase       ,	max_length=3       ,	max_target_length=10       ,	return_tensors="pt"						)
									self.assertEqual(batch_encoder_only.input_ids.shape[1]       ,	3						)
									self.assertEqual(batch_encoder_only.attention_mask.shape[1]       ,	3						)
									self.assertNotIn("decoder_input_ids"       ,	__lowercase						)






						@unittest.skip("Unfortunately way too slow to build a BPE with SentencePiece."						)
						def        snake_case__						(						self							:     Any						):






							"""simple docstring"""






							pass






						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
								with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"						):
									snake_case_		    =     [AddedToken("<special>"       ,	lstrip=__lowercase						)]

									snake_case_		    =     self.rust_tokenizer_class.from_pretrained(
									    __lowercase       ,	additional_special_tokens=__lowercase       ,	**__lowercase						)
									snake_case_		    =     tokenizer_r.encode("Hey this is a <special> token"						)

									snake_case_		    =     tokenizer_r.encode("<special>"       ,	add_special_tokens=__lowercase						)[0]

									self.assertTrue(special_token_id in r_output						)

									if self.test_slow_tokenizer:
										snake_case_		    =     self.rust_tokenizer_class.from_pretrained(
										    __lowercase       ,	additional_special_tokens=__lowercase       ,	**__lowercase       ,	)
										snake_case_		    =     self.tokenizer_class.from_pretrained(
										    __lowercase       ,	additional_special_tokens=__lowercase       ,	**__lowercase						)

										snake_case_		    =     tokenizer_p.encode("Hey this is a <special> token"						)

										snake_case_		    =     tokenizer_cr.encode("Hey this is a <special> token"						)

										self.assertEqual(__lowercase       ,	__lowercase						)
										self.assertEqual(__lowercase       ,	__lowercase						)
										self.assertTrue(special_token_id in p_output						)
										self.assertTrue(special_token_id in cr_output						)







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







						'''simple docstring'''





						lowerCAmelCase_     		=   """facebook/nllb-200-distilled-600M"""
						lowerCAmelCase_     		=   [
						    """ 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.""",
						]
						lowerCAmelCase_     		=   [
						    """Ş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.""",
						]
						lowerCAmelCase_     		=   [
						    25_6047,
						    1_6297,
						    13_4408,
						    8165,
						    24_8066,
						    1_4734,
						    950,
						    1135,
						    10_5721,
						    3573,
						    83,
						    2_7352,
						    108,
						    4_9486,
						    2,
						]






						@classmethod
						def        snake_case__						(						cls							:     Optional[Any]						):






							"""simple docstring"""






							snake_case_		    =     NllbTokenizer.from_pretrained(
							    cls.checkpoint_name       ,	src_lang="eng_Latn"       ,	tgt_lang="ron_Latn"						)
							snake_case_		    =     1
							return cls






						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Arab"]       ,	25_60_01						)
							self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Latn"]       ,	25_60_02						)
							self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["fra_Latn"]       ,	25_60_57						)






						def        snake_case__						(						self							:     Any						):






							"""simple docstring"""






							snake_case_		    =     self.tokenizer.batch_encode_plus(self.src_text						).input_ids[0]
							self.assertListEqual(self.expected_src_tokens       ,	__lowercase						)






						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






							self.assertIn(__lowercase       ,	self.tokenizer.all_special_ids						)
							# fmt: off
							snake_case_		    =     [RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47]
							# fmt: on

							snake_case_		    =     self.tokenizer.decode(__lowercase       ,	skip_special_tokens=__lowercase						)
							snake_case_		    =     self.tokenizer.decode(generated_ids[1:]       ,	skip_special_tokens=__lowercase						)
							self.assertEqual(__lowercase       ,	__lowercase						)
							self.assertNotIn(self.tokenizer.eos_token       ,	__lowercase						)






						def        snake_case__						(						self							:     Optional[Any]						):






							"""simple docstring"""






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






						def        snake_case__						(						self							:     Optional[Any]						):






							"""simple docstring"""






							self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"]						)       ,	[25_62_03, 3]						)






						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							snake_case_		    =     tempfile.mkdtemp()
							snake_case_		    =     self.tokenizer.fairseq_tokens_to_ids
							self.tokenizer.save_pretrained(__lowercase						)
							snake_case_		    =     NllbTokenizer.from_pretrained(__lowercase						)
							self.assertDictEqual(new_tok.fairseq_tokens_to_ids       ,	__lowercase						)






						@require_torch
						def        snake_case__						(						self							:     Tuple						):






							"""simple docstring"""






							snake_case_		    =     self.tokenizer(
							    self.src_text       ,	text_target=self.tgt_text       ,	padding=__lowercase       ,	truncation=__lowercase       ,	max_length=len(self.expected_src_tokens						)       ,	return_tensors="pt"       ,	)
							snake_case_		    =     shift_tokens_right(
							    batch["labels"]       ,	self.tokenizer.pad_token_id       ,	self.tokenizer.lang_code_to_id["ron_Latn"]						)

							self.assertIsInstance(__lowercase       ,	__lowercase						)

							self.assertEqual((2, 15)       ,	batch.input_ids.shape						)
							self.assertEqual((2, 15)       ,	batch.attention_mask.shape						)
							snake_case_		    =     batch.input_ids.tolist()[0]
							self.assertListEqual(self.expected_src_tokens       ,	__lowercase						)
							self.assertEqual(__lowercase       ,	batch.decoder_input_ids[0, 0]						)  # EOS
							# 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        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






							snake_case_		    =     self.tokenizer(self.src_text       ,	padding=__lowercase       ,	truncation=__lowercase       ,	max_length=3       ,	return_tensors="pt"						)
							snake_case_		    =     self.tokenizer(
							    text_target=self.tgt_text       ,	padding=__lowercase       ,	truncation=__lowercase       ,	max_length=10       ,	return_tensors="pt"						)
							snake_case_		    =     targets['input_ids']
							snake_case_		    =     shift_tokens_right(
							    __lowercase       ,	self.tokenizer.pad_token_id       ,	decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]       ,	)

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






						@require_torch
						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							snake_case_		    =     self.tokenizer._build_translation_inputs(
							    "A test"       ,	return_tensors="pt"       ,	src_lang="eng_Latn"       ,	tgt_lang="fra_Latn"						)

							self.assertEqual(
							    nested_simplify(__lowercase						)       ,	{
							        # A, test, EOS, en_XX
							        "input_ids": [[25_60_47, 70, 73_56, 2]],
							        "attention_mask": [[1, 1, 1, 1]],
							        # ar_AR
							        "forced_bos_token_id": 25_60_57,
							    }       ,	)






						@require_torch
						def        snake_case__						(						self							:     Optional[int]						):






							"""simple docstring"""






							snake_case_		    =     True
							snake_case_		    =     self.tokenizer(
							    "UN Chief says there is no military solution in Syria"       ,	src_lang="eng_Latn"       ,	tgt_lang="fra_Latn"						)
							self.assertEqual(
							    inputs.input_ids       ,	[1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47]						)

							snake_case_		    =     False
							snake_case_		    =     self.tokenizer(
							    "UN Chief says there is no military solution in Syria"       ,	src_lang="eng_Latn"       ,	tgt_lang="fra_Latn"						)
							self.assertEqual(
							    inputs.input_ids       ,	[25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2]						)




import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


SCREAMING_SNAKE_CASE       :      int												= logging.get_logger(__name__)

SCREAMING_SNAKE_CASE       :      List[str]												= {
    "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json",
    # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr
}






class _lowerCamelCase(						_a   ):
       lowercase_ :	Dict     =			"""deformable_detr"""
       lowercase_ :	int     =			{
           """hidden_size""": """d_model""",
           """num_attention_heads""": """encoder_attention_heads""",
       }
       def __init__(					self,      lowerCamelCase=True,      lowerCamelCase=None,      lowerCamelCase=3,      lowerCamelCase=3_00,      lowerCamelCase=10_24,      lowerCamelCase=6,      lowerCamelCase=10_24,      lowerCamelCase=8,      lowerCamelCase=6,      lowerCamelCase=10_24,      lowerCamelCase=8,      lowerCamelCase=0.0,      lowerCamelCase=True,      lowerCamelCase="relu",      lowerCamelCase=2_56,      lowerCamelCase=0.1,      lowerCamelCase=0.0,      lowerCamelCase=0.0,      lowerCamelCase=0.0_2,      lowerCamelCase=1.0,      lowerCamelCase=True,      lowerCamelCase=False,      lowerCamelCase="sine",      lowerCamelCase="resnet50",      lowerCamelCase=True,      lowerCamelCase=False,      lowerCamelCase=4,      lowerCamelCase=4,      lowerCamelCase=4,      lowerCamelCase=False,      lowerCamelCase=3_00,      lowerCamelCase=False,      lowerCamelCase=1,      lowerCamelCase=5,      lowerCamelCase=2,      lowerCamelCase=1,      lowerCamelCase=1,      lowerCamelCase=5,      lowerCamelCase=2,      lowerCamelCase=0.1,      lowerCamelCase=0.2_5,      lowerCamelCase=False,      **lowerCamelCase,      )       ->   Optional[int]:




           """simple docstring"""

           if backbone_config is not None and use_timm_backbone:
               raise ValueError('You can\'t specify both `backbone_config` and `use_timm_backbone`.')

           if not use_timm_backbone:
               if backbone_config is None:
                   logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.')
                   _lowercase       :							List[str]      		=		CONFIG_MAPPING['resnet'](out_features=['stage4'])
               elif isinstance(lowerCamelCase,      lowerCamelCase):
                   _lowercase       :							List[str]      		=		backbone_config.get('model_type')
                   _lowercase       :							str      		=		CONFIG_MAPPING[backbone_model_type]
                   _lowercase       :							Optional[int]      		=		config_class.from_dict(lowerCamelCase)
           _lowercase       :							Tuple      		=		use_timm_backbone
           _lowercase       :							List[str]      		=		backbone_config
           _lowercase       :							Tuple      		=		num_channels
           _lowercase       :							Optional[Any]      		=		num_queries
           _lowercase       :							Optional[Any]      		=		max_position_embeddings
           _lowercase       :							Optional[int]      		=		d_model
           _lowercase       :							int      		=		encoder_ffn_dim
           _lowercase       :							List[Any]      		=		encoder_layers
           _lowercase       :							str      		=		encoder_attention_heads
           _lowercase       :							str      		=		decoder_ffn_dim
           _lowercase       :							Optional[Any]      		=		decoder_layers
           _lowercase       :							List[str]      		=		decoder_attention_heads
           _lowercase       :							Optional[int]      		=		dropout
           _lowercase       :							Optional[Any]      		=		attention_dropout
           _lowercase       :							int      		=		activation_dropout
           _lowercase       :							Any      		=		activation_function
           _lowercase       :							Optional[int]      		=		init_std
           _lowercase       :							int      		=		init_xavier_std
           _lowercase       :							Union[str, Any]      		=		encoder_layerdrop
           _lowercase       :							Tuple      		=		auxiliary_loss
           _lowercase       :							Union[str, Any]      		=		position_embedding_type
           _lowercase       :							str      		=		backbone
           _lowercase       :							List[Any]      		=		use_pretrained_backbone
           _lowercase       :							Any      		=		dilation
           # deformable attributes
           _lowercase       :							Any      		=		num_feature_levels
           _lowercase       :							Dict      		=		encoder_n_points
           _lowercase       :							Dict      		=		decoder_n_points
           _lowercase       :							Dict      		=		two_stage
           _lowercase       :							Union[str, Any]      		=		two_stage_num_proposals
           _lowercase       :							str      		=		with_box_refine
           if two_stage is True and with_box_refine is False:
               raise ValueError('If two_stage is True, with_box_refine must be True.')
           # Hungarian matcher
           _lowercase       :							Tuple      		=		class_cost
           _lowercase       :							int      		=		bbox_cost
           _lowercase       :							Optional[int]      		=		giou_cost
           # Loss coefficients
           _lowercase       :							Optional[Any]      		=		mask_loss_coefficient
           _lowercase       :							Dict      		=		dice_loss_coefficient
           _lowercase       :							Tuple      		=		bbox_loss_coefficient
           _lowercase       :							Optional[int]      		=		giou_loss_coefficient
           _lowercase       :							Union[str, Any]      		=		eos_coefficient
           _lowercase       :							Union[str, Any]      		=		focal_alpha
           _lowercase       :							Dict      		=		disable_custom_kernels
           super().__init__(is_encoder_decoder=lowerCamelCase,      **lowerCamelCase)
       @property
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           return self.encoder_attention_heads
       @property
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           return self.d_model




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




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		copy.deepcopy(self.__dict__)
           if self.backbone_config is not None:
               _lowercase       :							Union[str, Any]      		=		self.backbone_config.to_dict()
           _lowercase       :							Tuple      		=		self.__class__.model_type
           return output


