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


_UpperCAmelCase            =		get_tests_dir("""fixtures/test_sentencepiece.model""")


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

_UpperCAmelCase            =		256047
_UpperCAmelCase            =		256145





@require_sentencepiece
@require_tokenizers
class UpperCAmelCase						( __A ,	unittest.TestCase  ):


				'''simple docstring'''






				lowerCamelCase_    = NllbTokenizer
				lowerCamelCase_    = NllbTokenizerFast
				lowerCamelCase_    = True
				lowerCamelCase_    = True
				lowerCamelCase_    = {}
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						super().setUp()

						# We have a SentencePiece fixture for testing
						A_		:    Dict         =				NllbTokenizer(lowercase		,     keep_accents=lowercase )
						tokenizer.save_pretrained(self.tmpdirname )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Optional[int]         =				NllbTokenizer(lowercase		,     keep_accents=lowercase )

						A_		:    int         =				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_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]		,     )

						A_		:    str         =				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',
						        'é',
						        '.',
						    ]		,     )
						A_		:    int         =				tokenizer.convert_tokens_to_ids(lowercase )
						self.assertListEqual(
						    lowercase		,     [
						        value + tokenizer.fairseq_offset
						        for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
						    ]		,     )

						A_		:    Dict         =				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   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Optional[int]         =				(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})''' ):
										A_		:    Union[str, Any]         =				self.rust_tokenizer_class.from_pretrained(lowercase		,     **lowercase )
										A_		:    int         =				self.tokenizer_class.from_pretrained(lowercase		,     **lowercase )

										A_		:    Any         =				tempfile.mkdtemp()

										A_		:    int         =				tokenizer_r.save_pretrained(lowercase )
										A_		:    str         =				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 ) )
										A_		:    Optional[int]         =				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
										A_		:    List[str]         =				tokenizer_r.from_pretrained(lowercase )
										A_		:    Optional[int]         =				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
										A_		:    Union[str, Any]         =				tempfile.mkdtemp()

										A_		:    Union[str, Any]         =				tokenizer_r.save_pretrained(lowercase		,     legacy_format=lowercase )
										A_		:    int         =				tokenizer_p.save_pretrained(lowercase )

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

										# Checks everything loads correctly in the same way
										A_		:    Optional[Any]         =				tokenizer_r.from_pretrained(lowercase )
										A_		:    Dict         =				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
										A_		:    Tuple         =				tempfile.mkdtemp()

										A_		:    Dict         =				tokenizer_r.save_pretrained(lowercase		,     legacy_format=lowercase )
										A_		:    List[str]         =				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
										A_		:    Tuple         =				tokenizer_r.from_pretrained(lowercase )
										A_		:    Dict         =				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   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						if not self.test_seqaseq:
								return

						A_		:    Any         =				self.get_tokenizers()
						for tokenizer in tokenizers:
								with self.subTest(F'''{tokenizer.__class__.__name__}''' ):
										# Longer text that will definitely require truncation.
										A_		:    Union[str, Any]         =				[
										    ' 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.',
										]
										A_		:    Optional[int]         =				[
										    'Ş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:
												A_		:    Union[str, Any]         =				tokenizer.prepare_seqaseq_batch(
												    src_texts=lowercase		,     tgt_texts=lowercase		,     max_length=3		,     max_target_length=1_0		,     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]		,     1_0 )
										# max_target_length will default to max_length if not specified
										A_		:    Tuple         =				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 )

										A_		:    Optional[int]         =				tokenizer.prepare_seqaseq_batch(
										    src_texts=lowercase		,     max_length=3		,     max_target_length=1_0		,     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   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						pass







				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
								with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
										A_		:    Tuple         =				[AddedToken('<special>'		,     lstrip=lowercase )]

										A_		:    List[Any]         =				self.rust_tokenizer_class.from_pretrained(
										    lowercase		,     additional_special_tokens=lowercase		,     **lowercase )
										A_		:    str         =				tokenizer_r.encode('Hey this is a <special> token' )

										A_		:    Optional[int]         =				tokenizer_r.encode('<special>'		,     add_special_tokens=lowercase )[0]

										self.assertTrue(special_token_id in r_output )

										if self.test_slow_tokenizer:
												A_		:    int         =				self.rust_tokenizer_class.from_pretrained(
												    lowercase		,     additional_special_tokens=lowercase		,     **lowercase		,     )
												A_		:    Union[str, Any]         =				self.tokenizer_class.from_pretrained(
												    lowercase		,     additional_special_tokens=lowercase		,     **lowercase )

												A_		:    int         =				tokenizer_p.encode('Hey this is a <special> token' )

												A_		:    Optional[int]         =				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_    = [
				    2_5_6_0_4_7,
				    1_6_2_9_7,
				    1_3_4_4_0_8,
				    8_1_6_5,
				    2_4_8_0_6_6,
				    1_4_7_3_4,
				    9_5_0,
				    1_1_3_5,
				    1_0_5_7_2_1,
				    3_5_7_3,
				    8_3,
				    2_7_3_5_2,
				    1_0_8,
				    4_9_4_8_6,
				    2,
				]
				@classmethod
				def   lowerCAmelCase_       (						cls ):



						"""simple docstring"""





						A_		:    NllbTokenizer         =				NllbTokenizer.from_pretrained(
						    cls.checkpoint_name		,     src_lang='eng_Latn'		,     tgt_lang='ron_Latn' )
						A_		:    Optional[int]         =				1
						return cls
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab']		,     2_5_6_0_0_1 )
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn']		,     2_5_6_0_0_2 )
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn']		,     2_5_6_0_5_7 )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    List[Any]         =				self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0]
						self.assertListEqual(self.expected_src_tokens		,     lowercase )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						self.assertIn(lowercase		,     self.tokenizer.all_special_ids )
						# fmt: off
						A_		:    List[Any]         =				[RO_CODE, 4_2_5_4, 9_8_0_6_8, 1_1_2_9_2_3, 3_9_0_7_2, 3_9_0_9, 7_1_3, 1_0_2_7_6_7, 2_6, 1_7_3_1_4, 3_5_6_4_2, 1_4_6_8_3, 3_3_1_1_8, 2_0_2_2, 6_6_9_8_7, 2, 2_5_6_0_4_7]
						# fmt: on

						A_		:    Tuple         =				self.tokenizer.decode(lowercase		,     skip_special_tokens=lowercase )
						A_		:    int         =				self.tokenizer.decode(generated_ids[1:]		,     skip_special_tokens=lowercase )
						self.assertEqual(lowercase		,     lowercase )
						self.assertNotIn(self.tokenizer.eos_token		,     lowercase )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Optional[int]         =				['this is gunna be a long sentence ' * 2_0]
						assert isinstance(src_text[0]		,     lowercase )
						A_		:    Any         =				1_0
						A_		:    List[Any]         =				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   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR'] )		,     [2_5_6_2_0_3, 3] )
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    List[str]         =				tempfile.mkdtemp()
						A_		:    str         =				self.tokenizer.fairseq_tokens_to_ids
						self.tokenizer.save_pretrained(lowercase )
						A_		:    List[Any]         =				NllbTokenizer.from_pretrained(lowercase )
						self.assertDictEqual(new_tok.fairseq_tokens_to_ids		,     lowercase )
				@require_torch
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Dict         =				self.tokenizer(
						    self.src_text		,     text_target=self.tgt_text		,     padding=lowercase		,     truncation=lowercase		,     max_length=len(self.expected_src_tokens )		,     return_tensors='pt'		,     )
						A_		:    str         =				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, 1_5)		,     batch.input_ids.shape )
						self.assertEqual((2, 1_5)		,     batch.attention_mask.shape )
						A_		:    Dict         =				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   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Optional[Any]         =				self.tokenizer(self.src_text		,     padding=lowercase		,     truncation=lowercase		,     max_length=3		,     return_tensors='pt' )
						A_		:    Any         =				self.tokenizer(
						    text_target=self.tgt_text		,     padding=lowercase		,     truncation=lowercase		,     max_length=1_0		,     return_tensors='pt' )
						A_		:    str         =				targets['input_ids']
						A_		:    List[str]         =				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]		,     1_0 )
				@require_torch
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Any         =				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': [[2_5_6_0_4_7, 7_0, 7_3_5_6, 2]],
						        'attention_mask': [[1, 1, 1, 1]],
						        # ar_AR
						        'forced_bos_token_id': 2_5_6_0_5_7,
						    }		,     )







				@require_torch
				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    Union[str, Any]         =				True
						A_		:    Optional[Any]         =				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_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2, 2_5_6_0_4_7] )

						A_		:    Any         =				False
						A_		:    str         =				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		,     [2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2] )







import copy
from typing import Dict, List, Optional

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


_UpperCAmelCase            =		{
    """facebook/mask2former-swin-small-coco-instance""": (
        """https://huggingface.co/facebook/mask2former-swin-small-coco-instance/blob/main/config.json"""
    )
    # See all Mask2Former models at https://huggingface.co/models?filter=mask2former
}

_UpperCAmelCase            =		logging.get_logger(__name__)





class UpperCAmelCase						( __A  ):


				'''simple docstring'''






				lowerCamelCase_    = '''mask2former'''
				lowerCamelCase_    = ['''swin''']
				lowerCamelCase_    = {'''hidden_size''': '''hidden_dim'''}
				def __init__(						self		,     lowercase = None		,     lowercase = 2_5_6		,     lowercase = 2_5_6		,     lowercase = 2_5_6		,     lowercase = 1_0_2_4		,     lowercase = "relu"		,     lowercase = 6		,     lowercase = 1_0		,     lowercase = 8		,     lowercase = 0.0		,     lowercase = 2_0_4_8		,     lowercase = False		,     lowercase = False		,     lowercase = 4		,     lowercase = 2_5_5		,     lowercase = 1_0_0		,     lowercase = 0.1		,     lowercase = 2.0		,     lowercase = 5.0		,     lowercase = 5.0		,     lowercase = 1_2_5_4_4		,     lowercase = 3.0		,     lowercase = 0.75		,     lowercase = 0.02		,     lowercase = 1.0		,     lowercase = True		,     lowercase = [4, 8, 1_6, 3_2]		,     lowercase = None		,     **lowercase		,     ):



						"""simple docstring"""





						if backbone_config is None:
								logger.info('`backbone_config` is `None`. Initializing the config with the default `Swin` backbone.' )
								A_		:    List[str]         =				CONFIG_MAPPING['swin'](
								    image_size=2_2_4		,     in_channels=3		,     patch_size=4		,     embed_dim=9_6		,     depths=[2, 2, 1_8, 2]		,     num_heads=[3, 6, 1_2, 2_4]		,     window_size=7		,     drop_path_rate=0.3		,     use_absolute_embeddings=lowercase		,     out_features=['stage1', 'stage2', 'stage3', 'stage4']		,     )

						if isinstance(lowercase		,     lowercase ):
								A_		:    str         =				backbone_config.pop('model_type' )
								A_		:    List[str]         =				CONFIG_MAPPING[backbone_model_type]
								A_		:    Tuple         =				config_class.from_dict(lowercase )

						# verify that the backbone is supported
						if backbone_config.model_type not in self.backbones_supported:
								logger.warning_once(
								    F'''Backbone {backbone_config.model_type} is not a supported model and may not be compatible with Mask2Former. '''
								    F'''Supported model types: {','.join(self.backbones_supported )}''' )

						A_		:    List[Any]         =				backbone_config
						A_		:    Optional[Any]         =				feature_size
						A_		:    int         =				mask_feature_size
						A_		:    Tuple         =				hidden_dim
						A_		:    Dict         =				encoder_feedforward_dim
						A_		:    int         =				activation_function
						A_		:    str         =				encoder_layers
						A_		:    Tuple         =				decoder_layers
						A_		:    Tuple         =				num_attention_heads
						A_		:    str         =				dropout
						A_		:    List[str]         =				dim_feedforward
						A_		:    List[str]         =				pre_norm
						A_		:    Tuple         =				enforce_input_projection
						A_		:    Dict         =				common_stride
						A_		:    Union[str, Any]         =				ignore_value
						A_		:    List[Any]         =				num_queries
						A_		:    List[Any]         =				no_object_weight
						A_		:    int         =				class_weight
						A_		:    int         =				mask_weight
						A_		:    Optional[Any]         =				dice_weight
						A_		:    int         =				train_num_points
						A_		:    Optional[int]         =				oversample_ratio
						A_		:    Tuple         =				importance_sample_ratio
						A_		:    Union[str, Any]         =				init_std
						A_		:    List[Any]         =				init_xavier_std
						A_		:    Optional[Any]         =				use_auxiliary_loss
						A_		:    Dict         =				feature_strides
						A_		:    List[Any]         =				output_auxiliary_logits
						A_		:    Optional[int]         =				decoder_layers

						super().__init__(**lowercase )
				@classmethod
				def   lowerCAmelCase_       (						cls		,     lowercase		,     **lowercase ):



						"""simple docstring"""





						return cls(
						    backbone_config=lowercase		,     **lowercase		,     )







				def   lowerCAmelCase_       (						self ):



						"""simple docstring"""





						A_		:    List[Any]         =				copy.deepcopy(self.__dict__ )
						A_		:    Optional[int]         =				self.backbone_config.to_dict()
						A_		:    Dict         =				self.__class__.model_type
						return output






