






"""simple docstring"""

from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
			import numpy as np
			import tensorflow as tf

			from transformers import (
			    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
			    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
			    TF_MODEL_FOR_MASKED_LM_MAPPING,
			    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
			    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
			    TF_MODEL_FOR_PRETRAINING_MAPPING,
			    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
			    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
			    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
			    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
			    TFSharedEmbeddings,
			)

			if _tf_gpu_memory_limit is not None:
						lowercase           =							tf.config.list_physical_devices('''GPU''')
						for gpu in gpus:
									# Restrict TensorFlow to only allocate x GB of memory on the GPUs
									try:
												tf.config.set_logical_device_configuration(
												    gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
												)
												lowercase           =							tf.config.list_logical_devices('''GPU''')
												print('''Logical GPUs''', logical_gpus)
									except RuntimeError as e:
												# Virtual devices must be set before GPUs have been initialized
												print(e)

@require_tf
class     A_				:
				UpperCAmelCase__										=					None
				UpperCAmelCase__										=					()
				UpperCAmelCase__										=					()
				UpperCAmelCase__										=					True
				UpperCAmelCase__										=					True
				UpperCAmelCase__										=					True
				UpperCAmelCase__										=					False







				def      _snake_case       (				self				:    Optional[int]    ,     __lowerCamelCase				:    Dict    ,     __lowerCamelCase				:    Dict    ,     __lowerCamelCase				:    Optional[Any]=False						)					->       dict:
										__magic_name__      =  copy.deepcopy(__lowerCamelCase						)

										if model_class in get_values(__lowerCamelCase						):
																__magic_name__      =  {
																    k: tf.tile(tf.expand_dims(__lowerCamelCase    ,     1						)    ,     (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)						)
																    if isinstance(__lowerCamelCase    ,     tf.Tensor						) and v.ndim > 0
																    else v
																    for k, v in inputs_dict.items()
																}

										if return_labels:
																if model_class in get_values(__lowerCamelCase						):
																						__magic_name__      =  tf.ones(self.model_tester.batch_size    ,     dtype=tf.intaa						)
																elif model_class in get_values(__lowerCamelCase						):
																						__magic_name__      =  tf.zeros(self.model_tester.batch_size    ,     dtype=tf.intaa						)
																						__magic_name__      =  tf.zeros(self.model_tester.batch_size    ,     dtype=tf.intaa						)
																elif model_class in [
																    *get_values(__lowerCamelCase						),
																    *get_values(__lowerCamelCase						),
																]:
																						__magic_name__      =  tf.zeros(self.model_tester.batch_size    ,     dtype=tf.intaa						)
																elif model_class in get_values(__lowerCamelCase						):
																						__magic_name__      =  tf.zeros(self.model_tester.batch_size    ,     dtype=tf.intaa						)
																elif model_class in [
																    *get_values(__lowerCamelCase						),
																    *get_values(__lowerCamelCase						),
																    *get_values(__lowerCamelCase						),
																    *get_values(__lowerCamelCase						),
																    *get_values(__lowerCamelCase						),
																]:
																						__magic_name__      =  tf.zeros(
																						    (self.model_tester.batch_size, self.model_tester.seq_length)    ,     dtype=tf.intaa						)
										return inputs_dict







				@slow
				def      _snake_case       (				self				:    List[str]						)					->       str:
										__magic_name__   ,     __magic_name__      =  self.model_tester.prepare_config_and_inputs_for_common()
										for model_class in self.all_model_classes[:2]:
																__magic_name__      =  self._prepare_for_class(__lowerCamelCase    ,     __lowerCamelCase						)
																__magic_name__      =  model_class(__lowerCamelCase						)

																@tf.function
																def run_in_graph_mode():
																						return model(__lowerCamelCase						)

																__magic_name__      =  run_in_graph_mode()
																self.assertIsNotNone(__lowerCamelCase						)







				@slow
				def      _snake_case       (				self				:    Any						)					->       Optional[int]:
										__magic_name__   ,     __magic_name__      =  self.model_tester.prepare_config_and_inputs_for_common()
										for model_class in self.all_model_classes[:2]:
																__magic_name__      =  self._prepare_for_class(__lowerCamelCase    ,     __lowerCamelCase						)
																__magic_name__      =  model_class(__lowerCamelCase						)

																@tf.function(experimental_compile=__lowerCamelCase						)
																def run_in_graph_mode():
																						return model(__lowerCamelCase						)

																__magic_name__      =  run_in_graph_mode()
																self.assertIsNotNone(__lowerCamelCase						)







				@slow
				def      _snake_case       (				self				:    Tuple						)					->       str:
										# This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
										__magic_name__   ,     __magic_name__      =  self.model_tester.prepare_config_and_inputs_for_common()
										for model_class in self.all_model_classes[:2]:
																__magic_name__      =  model_class(__lowerCamelCase						)
																if getattr(__lowerCamelCase    ,     "hf_compute_loss"    ,     __lowerCamelCase						):
																						# Test that model correctly compute the loss with kwargs
																						__magic_name__      =  self._prepare_for_class(inputs_dict.copy()    ,     __lowerCamelCase    ,     return_labels=__lowerCamelCase						)
																						# Is there a better way to remove these decoder inputs?
																						__magic_name__      =  {
																						    key: val
																						    for key, val in prepared_for_class.items()
																						    if key not in ("head_mask", "decoder_head_mask", "cross_attn_head_mask", "decoder_input_ids")
																						}

																						__magic_name__      =  {
																						    "labels",
																						    "label",
																						    "label_ids",
																						    "start_positions",
																						    "start_position",
																						    "end_positions",
																						    "end_position",
																						    "next_sentence_label",
																						}
																						__magic_name__      =  possible_label_cols.intersection(set(__lowerCamelCase						)						)
																						self.assertGreater(len(__lowerCamelCase						)    ,     0    ,     msg="No matching label names found!"						)
																						__magic_name__      =  {key: val for key, val in prepared_for_class.items() if key in label_names}
																						__magic_name__      =  {key: val for key, val in prepared_for_class.items() if key not in label_names}
																						self.assertGreater(len(__lowerCamelCase						)    ,     0						)

																						# Make sure it works with XLA!
																						model.compile(optimizer=tf.keras.optimizers.SGD(0.0						)    ,     jit_compile=__lowerCamelCase						)
																						# Make sure the model fits without crashing regardless of where we pass the labels
																						__magic_name__      =  model.fit(
																						    __lowerCamelCase    ,     validation_data=__lowerCamelCase    ,     steps_per_epoch=1    ,     validation_steps=1    ,     shuffle=__lowerCamelCase    ,     verbose=0    ,     )
																						__magic_name__      =  history.history["loss"][0]
																						self.assertTrue(not isnan(__lowerCamelCase						)						)
																						__magic_name__      =  history.history["val_loss"][0]
																						self.assertTrue(not isnan(__lowerCamelCase						)						)

																						# Now test it with separate labels, to make sure that path works in XLA too.
																						__magic_name__      =  model_class(__lowerCamelCase						)
																						model.compile(optimizer=tf.keras.optimizers.SGD(0.0						)    ,     jit_compile=__lowerCamelCase						)
																						__magic_name__      =  model.fit(
																						    __lowerCamelCase    ,     __lowerCamelCase    ,     validation_data=(inputs_minus_labels, labels)    ,     steps_per_epoch=1    ,     validation_steps=1    ,     shuffle=__lowerCamelCase    ,     verbose=0    ,     )

																						__magic_name__      =  history.history["loss"][0]
																						self.assertTrue(not isnan(__lowerCamelCase						)						)
																						__magic_name__      =  history.history["val_loss"][0]
																						self.assertTrue(not isnan(__lowerCamelCase						)						)







				@slow
				def      _snake_case       (				self				:    Optional[int]						)					->       Union[str, Any]:
										__magic_name__   ,     __magic_name__      =  self.model_tester.prepare_config_and_inputs_for_common()
										__magic_name__      =  True
										__magic_name__      =  True

										if hasattr(__lowerCamelCase    ,     "use_cache"						):
																__magic_name__      =  True

										__magic_name__      =  getattr(self.model_tester    ,     "encoder_seq_length"    ,     self.model_tester.seq_length						)
										__magic_name__      =  getattr(self.model_tester    ,     "key_length"    ,     __lowerCamelCase						)

										for model_class in self.all_model_classes[:2]:
																__magic_name__      =  self._prepare_for_class(__lowerCamelCase    ,     __lowerCamelCase						)
																__magic_name__      =  model_class(__lowerCamelCase						)
																model.build()
																__magic_name__      =  len(model(__lowerCamelCase						)						)

																for key in list(class_inputs_dict.keys()						):
																						# Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
																						if key not in model.input_signature:
																												del class_inputs_dict[key]
																						# Check it's a tensor, in case the inputs dict has some bools in it too
																						elif isinstance(class_inputs_dict[key]    ,     tf.Tensor						) and class_inputs_dict[key].dtype.is_integer:
																												__magic_name__      =  tf.cast(class_inputs_dict[key]    ,     tf.intaa						)

																if set(class_inputs_dict.keys()						) != set(model.input_signature.keys()						):
																						continue  # Some models have inputs that the preparation functions don't create, we skip those

																with tempfile.TemporaryDirectory() as tmpdirname:
																						model.save_pretrained(__lowerCamelCase    ,     saved_model=__lowerCamelCase						)
																						__magic_name__      =  os.path.join(__lowerCamelCase    ,     "saved_model"    ,     "1"						)
																						__magic_name__      =  tf.keras.models.load_model(__lowerCamelCase						)
																						__magic_name__      =  model(__lowerCamelCase						)

																						if self.is_encoder_decoder:
																												__magic_name__      =  outputs["encoder_hidden_states"]
																												__magic_name__      =  outputs["encoder_attentions"]
																						else:
																												__magic_name__      =  outputs["hidden_states"]
																												__magic_name__      =  outputs["attentions"]

																						self.assertEqual(len(__lowerCamelCase						)    ,     __lowerCamelCase						)

																						__magic_name__      =  getattr(
																						    self.model_tester    ,     "expected_num_hidden_layers"    ,     self.model_tester.num_hidden_layers + 1						)

																						self.assertEqual(len(__lowerCamelCase						)    ,     __lowerCamelCase						)
																						self.assertListEqual(
																						    list(output_hidden_states[0].shape[-2:]						)    ,     [self.model_tester.seq_length, self.model_tester.hidden_size]    ,     )

																						self.assertEqual(len(__lowerCamelCase						)    ,     self.model_tester.num_hidden_layers						)
																						self.assertListEqual(
																						    list(output_attentions[0].shape[-3:]						)    ,     [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]    ,     )







				@slow
				def      _snake_case       (				self				:    Tuple						)					->       List[str]:
										tf.keras.mixed_precision.set_global_policy("mixed_float16"						)

										# try/finally block to ensure subsequent tests run in float32
										try:
																__magic_name__   ,     __magic_name__      =  self.model_tester.prepare_config_and_inputs_for_common()
																for model_class in self.all_model_classes[:2]:
																						__magic_name__      =  self._prepare_for_class(__lowerCamelCase    ,     __lowerCamelCase						)
																						__magic_name__      =  model_class(__lowerCamelCase						)
																						__magic_name__      =  model(__lowerCamelCase						)

																						self.assertIsNotNone(__lowerCamelCase						)
										finally:
																tf.keras.mixed_precision.set_global_policy("float32"						)







				@slow
				def      _snake_case       (				self				:    Dict						)					->       str:
										__magic_name__   ,     __magic_name__      =  self.model_tester.prepare_config_and_inputs_for_common()
										# head_mask and decoder_head_mask has different shapes than other input args
										if "head_mask" in inputs_dict:
																del inputs_dict["head_mask"]
										if "decoder_head_mask" in inputs_dict:
																del inputs_dict["decoder_head_mask"]
										if "cross_attn_head_mask" in inputs_dict:
																del inputs_dict["cross_attn_head_mask"]
										__magic_name__      =  {
										    module_member
										    for model_class in self.all_model_classes
										    for module in (import_module(model_class.__module__						),)
										    for module_member_name in dir(__lowerCamelCase						)
										    if module_member_name.endswith("MainLayer"						)
										    for module_member in (getattr(__lowerCamelCase    ,     __lowerCamelCase						),)
										    if isinstance(__lowerCamelCase    ,     __lowerCamelCase						)
										    and tf.keras.layers.Layer in module_member.__bases__
										    and getattr(__lowerCamelCase    ,     "_keras_serializable"    ,     __lowerCamelCase						)
										}

										for main_layer_class in tf_main_layer_classes:
																# T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
																if "T5" in main_layer_class.__name__:
																						# Take the same values than in TFT5ModelTester for this shared layer
																						__magic_name__      =  TFSharedEmbeddings(self.model_tester.vocab_size    ,     self.model_tester.hidden_size    ,     name="shared"						)
																						__magic_name__      =  False
																						__magic_name__      =  main_layer_class(__lowerCamelCase    ,     embed_tokens=__lowerCamelCase						)
																else:
																						__magic_name__      =  main_layer_class(__lowerCamelCase						)

																__magic_name__      =  {
																    name: tf.keras.Input(tensor.shape[1:]    ,     dtype=tensor.dtype						) for name, tensor in inputs_dict.items()
																}

																if hasattr(self.model_tester    ,     "num_labels"						):
																						__magic_name__      =  self.model_tester.num_labels
																else:
																						__magic_name__      =  2

																__magic_name__      =  tf.data.Dataset.from_tensor_slices(
																    (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)						))						).batch(1						)

																__magic_name__      =  main_layer(__lowerCamelCase						)[0]
																__magic_name__      =  tf.keras.layers.Dense(__lowerCamelCase    ,     activation="softmax"    ,     name="outputs"						)(__lowerCamelCase						)
																__magic_name__      =  tf.keras.models.Model(inputs=__lowerCamelCase    ,     outputs=[outputs]						)

																model.compile(loss="binary_crossentropy"    ,     optimizer="adam"    ,     metrics=["binary_accuracy"]						)
																model.fit(__lowerCamelCase    ,     epochs=1						)

																with tempfile.TemporaryDirectory() as tmpdirname:
																						__magic_name__      =  os.path.join(__lowerCamelCase    ,     "keras_model.h5"						)
																						model.save(__lowerCamelCase						)
																						if "T5" in main_layer_class.__name__:
																												__magic_name__      =  tf.keras.models.load_model(
																												    __lowerCamelCase    ,     custom_objects={
																												        main_layer_class.__name__: main_layer_class,
																												        "TFSharedEmbeddings": TFSharedEmbeddings,
																												    }    ,     )
																						else:
																												__magic_name__      =  tf.keras.models.load_model(
																												    __lowerCamelCase    ,     custom_objects={main_layer_class.__name__: main_layer_class}						)
																						assert isinstance(__lowerCamelCase    ,     tf.keras.Model						)
																						model(__lowerCamelCase						)







				@slow
				def      _snake_case       (				self				:    Union[str, Any]						)					->       int:
										__magic_name__   ,     __magic_name__      =  self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes[:2]:
																__magic_name__      =  model_class(__lowerCamelCase						)

																__magic_name__      =  copy.deepcopy(__lowerCamelCase						)

																if not self.is_encoder_decoder:
																						__magic_name__      =  inputs["input_ids"]
																						del inputs["input_ids"]
																else:
																						__magic_name__      =  inputs["input_ids"]
																						__magic_name__      =  inputs.get("decoder_input_ids"    ,     __lowerCamelCase						)
																						del inputs["input_ids"]
																						inputs.pop("decoder_input_ids"    ,     __lowerCamelCase						)

																if not self.is_encoder_decoder:
																						__magic_name__      =  model.get_input_embeddings()(__lowerCamelCase						)
																else:
																						__magic_name__      =  model.get_input_embeddings()(__lowerCamelCase						)
																						__magic_name__      =  model.get_input_embeddings()(__lowerCamelCase						)

																__magic_name__      =  self._prepare_for_class(__lowerCamelCase    ,     __lowerCamelCase						)

																@tf.function
																def run_in_graph_mode():
																						return model(__lowerCamelCase						)

																__magic_name__      =  run_in_graph_mode()
																self.assertIsNotNone(__lowerCamelCase						)







				def      _snake_case       (				self				:    Tuple    ,     __lowerCamelCase				:    List[Any]    ,     __lowerCamelCase				:    int						)					->       Union[str, Any]:
										# special tokens cannot be bad tokens
										__magic_name__      =  []
										if model.config.bos_token_id is not None:
																special_tokens.append(model.config.bos_token_id						)
										if model.config.pad_token_id is not None:
																special_tokens.append(model.config.pad_token_id						)
										if model.config.eos_token_id is not None:
																special_tokens.append(model.config.eos_token_id						)

										# create random bad tokens that are not special tokens
										__magic_name__      =  []
										while len(__lowerCamelCase						) < num_bad_tokens:
																__magic_name__      =  tf.squeeze(ids_tensor((1, 1)    ,     self.model_tester.vocab_size						)    ,     0						).numpy()[0]
																if token not in special_tokens:
																						bad_tokens.append(__lowerCamelCase						)
										return bad_tokens







				def      _snake_case       (				self				:    str    ,     __lowerCamelCase				:    Dict						)					->       Union[str, Any]:
										for token_id in output_ids[0].numpy().tolist():
																self.assertGreaterEqual(__lowerCamelCase    ,     0						)
																self.assertLess(__lowerCamelCase    ,     self.model_tester.vocab_size						)







				def      _snake_case       (				self				:    Tuple    ,     __lowerCamelCase				:    List[Any]    ,     __lowerCamelCase				:    List[Any]						)					->       List[Any]:
										# for all bad word tokens
										for bad_word_ids in bad_words_ids:
																# for all slices in batch
																for generated_ids_slice in generated_ids:
																						# for all word idx
																						for i in range(len(__lowerCamelCase						)    ,     len(__lowerCamelCase						)						):
																												# if tokens match
																												if generated_ids_slice[i - len(__lowerCamelCase						) : i] == bad_word_ids:
																																		return True
										return False











"""simple docstring"""

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase           =							logging.get_logger(__name__)

lowercase           =							{
    '''facebook/sam-vit-huge''': '''https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json''',
    '''facebook/sam-vit-large''': '''https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json''',
    '''facebook/sam-vit-base''': '''https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json''',
}

class     A_				(   snake_case_	):







				def __init__(				self				:    List[Any]    ,     __lowerCamelCase				:    str=2_5_6    ,     __lowerCamelCase				:    str=1_0_2_4    ,     __lowerCamelCase				:    Optional[Any]=1_6    ,     __lowerCamelCase				:    Union[str, Any]=1_6    ,     __lowerCamelCase				:    str=4    ,     __lowerCamelCase				:    Union[str, Any]="gelu"    ,     __lowerCamelCase				:    Optional[int]=1e-6    ,     **__lowerCamelCase				:    str    ,     )					->       List[Any]:
										super().__init__(**__lowerCamelCase						)
										__magic_name__      =  hidden_size
										__magic_name__      =  image_size
										__magic_name__      =  patch_size
										__magic_name__      =  image_size // patch_size
										__magic_name__      =  mask_input_channels
										__magic_name__      =  num_point_embeddings
										__magic_name__      =  hidden_act
										__magic_name__      =  layer_norm_eps





class     A_				(   snake_case_	):







				def __init__(				self				:    List[str]    ,     __lowerCamelCase				:    Optional[Any]=2_5_6    ,     __lowerCamelCase				:    int="relu"    ,     __lowerCamelCase				:    List[str]=2_0_4_8    ,     __lowerCamelCase				:    Optional[Any]=2    ,     __lowerCamelCase				:    Optional[Any]=8    ,     __lowerCamelCase				:    Optional[Any]=2    ,     __lowerCamelCase				:    Dict=3    ,     __lowerCamelCase				:    Optional[int]=3    ,     __lowerCamelCase				:    Tuple=2_5_6    ,     __lowerCamelCase				:    List[str]=1e-6    ,     **__lowerCamelCase				:    Any    ,     )					->       str:
										super().__init__(**__lowerCamelCase						)
										__magic_name__      =  hidden_size
										__magic_name__      =  hidden_act
										__magic_name__      =  mlp_dim
										__magic_name__      =  num_hidden_layers
										__magic_name__      =  num_attention_heads
										__magic_name__      =  attention_downsample_rate
										__magic_name__      =  num_multimask_outputs
										__magic_name__      =  iou_head_depth
										__magic_name__      =  iou_head_hidden_dim
										__magic_name__      =  layer_norm_eps





class     A_				(   snake_case_	):







				def __init__(				self				:    Union[str, Any]    ,     __lowerCamelCase				:    str=7_6_8    ,     __lowerCamelCase				:    Optional[int]=2_5_6    ,     __lowerCamelCase				:    Tuple=1_2    ,     __lowerCamelCase				:    int=1_2    ,     __lowerCamelCase				:    int=3    ,     __lowerCamelCase				:    int=1_0_2_4    ,     __lowerCamelCase				:    Any=1_6    ,     __lowerCamelCase				:    Tuple="gelu"    ,     __lowerCamelCase				:    Dict=1e-06    ,     __lowerCamelCase				:    List[Any]=0.0    ,     __lowerCamelCase				:    Optional[Any]=1e-10    ,     __lowerCamelCase				:    str=True    ,     __lowerCamelCase				:    List[str]=4.0    ,     __lowerCamelCase				:    Union[str, Any]=True    ,     __lowerCamelCase				:    str=True    ,     __lowerCamelCase				:    Optional[Any]=1_4    ,     __lowerCamelCase				:    str=[2, 5, 8, 1_1]    ,     __lowerCamelCase				:    List[Any]=1_2_8    ,     __lowerCamelCase				:    Dict=None    ,     **__lowerCamelCase				:    List[str]    ,     )					->       Optional[int]:
										super().__init__(**__lowerCamelCase						)

										__magic_name__      =  hidden_size
										__magic_name__      =  output_channels
										__magic_name__      =  num_hidden_layers
										__magic_name__      =  num_attention_heads
										__magic_name__      =  num_channels
										__magic_name__      =  image_size
										__magic_name__      =  patch_size
										__magic_name__      =  hidden_act
										__magic_name__      =  layer_norm_eps
										__magic_name__      =  attention_dropout
										__magic_name__      =  initializer_range
										__magic_name__      =  qkv_bias
										__magic_name__      =  mlp_ratio
										__magic_name__      =  use_abs_pos
										__magic_name__      =  use_rel_pos
										__magic_name__      =  window_size
										__magic_name__      =  global_attn_indexes
										__magic_name__      =  num_pos_feats
										__magic_name__      =  int(hidden_size * mlp_ratio						) if mlp_dim is None else mlp_dim





class     A_				(   snake_case_	):
				UpperCAmelCase__										=					'''sam'''
				UpperCAmelCase__										=					True







				def __init__(				self				:    Optional[Any]    ,     __lowerCamelCase				:    Dict=None    ,     __lowerCamelCase				:    Dict=None    ,     __lowerCamelCase				:    Optional[Any]=None    ,     __lowerCamelCase				:    int=0.02    ,     **__lowerCamelCase				:    List[Any]    ,     )					->       List[str]:
										super().__init__(**__lowerCamelCase						)
										__magic_name__      =  vision_config if vision_config is not None else {}
										__magic_name__      =  prompt_encoder_config if prompt_encoder_config is not None else {}
										__magic_name__      =  mask_decoder_config if mask_decoder_config is not None else {}

										if isinstance(__lowerCamelCase    ,     __lowerCamelCase						):
																__magic_name__      =  vision_config.to_dict()
										if isinstance(__lowerCamelCase    ,     __lowerCamelCase						):
																__magic_name__      =  prompt_encoder_config.to_dict()
										if isinstance(__lowerCamelCase    ,     __lowerCamelCase						):
																__magic_name__      =  mask_decoder_config.to_dict()

										__magic_name__      =  SamVisionConfig(**__lowerCamelCase						)
										__magic_name__      =  SamPromptEncoderConfig(**__lowerCamelCase						)
										__magic_name__      =  SamMaskDecoderConfig(**__lowerCamelCase						)
										__magic_name__      =  initializer_range







				def      _snake_case       (				self				:    Optional[int]						)					->       str:
										__magic_name__      =  copy.deepcopy(self.__dict__						)
										__magic_name__      =  self.vision_config.to_dict()
										__magic_name__      =  self.prompt_encoder_config.to_dict()
										__magic_name__      =  self.mask_decoder_config.to_dict()
										__magic_name__      =  self.__class__.model_type
										return output



