



"""simple docstring"""
import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_MAPPING,
      LevitForImageClassification,
      LevitForImageClassificationWithTeacher,
      LevitModel,
  )
  from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import LevitImageProcessor
class 				_UpperCAmelCase				(					__A ):





     '''simple docstring'''



     def 					__lowerCAmelCase      (   self						)				->   str:
         _UpperCAmelCase				:    Dict											=       self.config_class(**self.inputs_dict						)
         self.parent.assertTrue(hasattr(lowerCAmelCase_			,      '''hidden_sizes'''						)						)
         self.parent.assertTrue(hasattr(lowerCAmelCase_			,      '''num_attention_heads'''						)						)



class 				_UpperCAmelCase				:





     '''simple docstring'''



     def __init__(   self			,      A			,      A=1_3			,      A=6_4			,      A=3			,      A=3			,      A=2			,      A=1			,      A=1_6			,      A=[1_2_8, 2_5_6, 3_8_4]			,      A=[4, 6, 8]			,      A=[2, 3, 4]			,      A=[1_6, 1_6, 1_6]			,      A=0			,      A=[2, 2, 2]			,      A=[2, 2, 2]			,      A=0.02			,      A=True			,      A=True			,      A=2			,      )				->   Any:
         _UpperCAmelCase				:    str											=       parent
         _UpperCAmelCase				:    str											=       batch_size
         _UpperCAmelCase				:    Tuple											=       image_size
         _UpperCAmelCase				:    Dict											=       num_channels
         _UpperCAmelCase				:    List[Any]											=       kernel_size
         _UpperCAmelCase				:    List[Any]											=       stride
         _UpperCAmelCase				:    Optional[int]											=       padding
         _UpperCAmelCase				:    Dict											=       hidden_sizes
         _UpperCAmelCase				:    List[Any]											=       num_attention_heads
         _UpperCAmelCase				:    Optional[int]											=       depths
         _UpperCAmelCase				:    Union[str, Any]											=       key_dim
         _UpperCAmelCase				:    Any											=       drop_path_rate
         _UpperCAmelCase				:    List[str]											=       patch_size
         _UpperCAmelCase				:    str											=       attention_ratio
         _UpperCAmelCase				:    str											=       mlp_ratio
         _UpperCAmelCase				:    List[Any]											=       initializer_range
         _UpperCAmelCase				:    Union[str, Any]											=       [
             ["Subsample", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
             ["Subsample", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
         ]
         _UpperCAmelCase				:    List[Any]											=       is_training
         _UpperCAmelCase				:    Optional[Any]											=       use_labels
         _UpperCAmelCase				:    Dict											=       num_labels
         _UpperCAmelCase				:    Any											=       initializer_range





     def 					__lowerCAmelCase      (   self						)				->   Tuple:
         _UpperCAmelCase				:    Optional[Any]											=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

         _UpperCAmelCase				:    List[str]											=       None
         if self.use_labels:
             _UpperCAmelCase				:    Dict											=       ids_tensor([self.batch_size]			,      self.num_labels						)

         _UpperCAmelCase				:    Optional[Any]											=       self.get_config()
         return config, pixel_values, labels





     def 					__lowerCAmelCase      (   self						)				->   Optional[Any]:
         return LevitConfig(
             image_size=self.image_size			,      num_channels=self.num_channels			,      kernel_size=self.kernel_size			,      stride=self.stride			,      padding=self.padding			,      patch_size=self.patch_size			,      hidden_sizes=self.hidden_sizes			,      num_attention_heads=self.num_attention_heads			,      depths=self.depths			,      key_dim=self.key_dim			,      drop_path_rate=self.drop_path_rate			,      mlp_ratio=self.mlp_ratio			,      attention_ratio=self.attention_ratio			,      initializer_range=self.initializer_range			,      down_ops=self.down_ops			,      )





     def 					__lowerCAmelCase      (   self			,      A			,      A			,      A						)				->   Optional[int]:
         _UpperCAmelCase				:    Any											=       LevitModel(config=lowerCAmelCase_						)
         model.to(lowerCAmelCase_						)
         model.eval()
         _UpperCAmelCase				:    Any											=       model(lowerCAmelCase_						)
         _UpperCAmelCase				:    Dict											=       (self.image_size, self.image_size)
         _UpperCAmelCase				:    Tuple											=       image_size[0], image_size[1]
         for _ in range(4						):
             _UpperCAmelCase				:    List[str]											=       floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
             _UpperCAmelCase				:    Dict											=       floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
         self.parent.assertEqual(
             result.last_hidden_state.shape			,      (self.batch_size, ceil(height / 4						) * ceil(width / 4						), self.hidden_sizes[-1])			,      )





     def 					__lowerCAmelCase      (   self			,      A			,      A			,      A						)				->   Optional[Any]:
         _UpperCAmelCase				:    Optional[int]											=       self.num_labels
         _UpperCAmelCase				:    Optional[Any]											=       LevitForImageClassification(lowerCAmelCase_						)
         model.to(lowerCAmelCase_						)
         model.eval()
         _UpperCAmelCase				:    Dict											=       model(lowerCAmelCase_			,      labels=lowerCAmelCase_						)
         self.parent.assertEqual(result.logits.shape			,      (self.batch_size, self.num_labels)						)





     def 					__lowerCAmelCase      (   self						)				->   List[Any]:
         _UpperCAmelCase				:    str											=       self.prepare_config_and_inputs()
         _UpperCAmelCase				:    int											=       config_and_inputs
         _UpperCAmelCase				:    Optional[Any]											=       {"pixel_values": pixel_values}
         return config, inputs_dict



@require_torch
class 				_UpperCAmelCase				(					__A						,__A						,unittest.TestCase ):





     '''simple docstring'''



     a__   							=(
         (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
         if is_torch_available()
         else ()
     )
     a__   							=(
         {
             '''feature-extraction''': LevitModel,
             '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
         }
         if is_torch_available()
         else {}
     )

     a__   							=False
     a__   							=False
     a__   							=False
     a__   							=False
     a__   							=False





     def 					__lowerCAmelCase      (   self						)				->   List[Any]:
         _UpperCAmelCase				:    str											=       LevitModelTester(self						)
         _UpperCAmelCase				:    Any											=       ConfigTester(self			,      config_class=lowerCAmelCase_			,      has_text_modality=lowerCAmelCase_			,      hidden_size=3_7						)





     def 					__lowerCAmelCase      (   self						)				->   Optional[int]:
         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()





     def 					__lowerCAmelCase      (   self						)				->   Tuple:
         return





     @unittest.skip(reason='''Levit does not use inputs_embeds'''						)
     def 					__lowerCAmelCase      (   self						)				->   str:
         pass





     @unittest.skip(reason='''Levit does not support input and output embeddings'''						)
     def 					__lowerCAmelCase      (   self						)				->   Optional[int]:
         pass





     @unittest.skip(reason='''Levit does not output attentions'''						)
     def 					__lowerCAmelCase      (   self						)				->   Dict:
         pass





     def 					__lowerCAmelCase      (   self						)				->   Optional[int]:
         _UpperCAmelCase				:    Any											=       self.model_tester.prepare_config_and_inputs_for_common()

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

             _UpperCAmelCase				:    Any											=       ["pixel_values"]
             self.assertListEqual(arg_names[:1]			,      lowerCAmelCase_						)





     def 					__lowerCAmelCase      (   self						)				->   Tuple:
         def check_hidden_states_output(A			,      A			,      A						):
             _UpperCAmelCase				:    Dict											=       model_class(lowerCAmelCase_						)
             model.to(lowerCAmelCase_						)
             model.eval()

             with torch.no_grad():
                 _UpperCAmelCase				:    Any											=       model(**self._prepare_for_class(lowerCAmelCase_			,      lowerCAmelCase_						)						)

             _UpperCAmelCase				:    str											=       outputs.hidden_states

             _UpperCAmelCase				:    List[str]											=       len(self.model_tester.depths						) + 1
             self.assertEqual(len(lowerCAmelCase_						)			,      lowerCAmelCase_						)

             _UpperCAmelCase				:    Dict											=       (self.model_tester.image_size, self.model_tester.image_size)
             _UpperCAmelCase				:    List[str]											=       image_size[0], image_size[1]
             for _ in range(4						):
                 _UpperCAmelCase				:    Dict											=       floor(
                     (
                         (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                         / self.model_tester.stride
                     )
                     + 1						)
                 _UpperCAmelCase				:    List[Any]											=       floor(
                     (
                         (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                         / self.model_tester.stride
                     )
                     + 1						)
             # verify the first hidden states (first block)
             self.assertListEqual(
                 list(hidden_states[0].shape[-2:]						)			,      [
                     height * width,
                     self.model_tester.hidden_sizes[0],
                 ]			,      )

         _UpperCAmelCase				:    str											=       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             _UpperCAmelCase				:    List[str]											=       True
             check_hidden_states_output(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_						)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             _UpperCAmelCase				:    str											=       True

             check_hidden_states_output(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_						)





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





     def 					__lowerCAmelCase      (   self			,      A			,      A			,      A=False						)				->   Optional[Any]:
         _UpperCAmelCase				:    List[Any]											=       super()._prepare_for_class(lowerCAmelCase_			,      lowerCAmelCase_			,      return_labels=lowerCAmelCase_						)

         if return_labels:
             if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                 del inputs_dict["labels"]

         return inputs_dict





     def 					__lowerCAmelCase      (   self						)				->   Any:
         _UpperCAmelCase				:    Optional[int]											=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCAmelCase_						)





     def 					__lowerCAmelCase      (   self						)				->   Optional[Any]:
         _UpperCAmelCase				:    str											=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_						)





     def 					__lowerCAmelCase      (   self						)				->   Dict:
         if not self.model_tester.is_training:
             return

         _UpperCAmelCase				:    List[str]											=       self.model_tester.prepare_config_and_inputs_for_common()
         _UpperCAmelCase				:    Optional[Any]											=       True

         for model_class in self.all_model_classes:
             # LevitForImageClassificationWithTeacher supports inference-only
             if (
                 model_class in get_values(lowerCAmelCase_						)
                 or model_class.__name__ == "LevitForImageClassificationWithTeacher"
             ):
                 continue
             _UpperCAmelCase				:    int											=       model_class(lowerCAmelCase_						)
             model.to(lowerCAmelCase_						)
             model.train()
             _UpperCAmelCase				:    Dict											=       self._prepare_for_class(lowerCAmelCase_			,      lowerCAmelCase_			,      return_labels=lowerCAmelCase_						)
             _UpperCAmelCase				:    Any											=       model(**lowerCAmelCase_						).loss
             loss.backward()





     def 					__lowerCAmelCase      (   self						)				->   List[Any]:
         _UpperCAmelCase				:    Tuple											=       self.model_tester.prepare_config_and_inputs_for_common()
         if not self.model_tester.is_training:
             return

         _UpperCAmelCase				:    Tuple											=       False
         _UpperCAmelCase				:    Tuple											=       True

         for model_class in self.all_model_classes:
             if model_class in get_values(lowerCAmelCase_						) or not model_class.supports_gradient_checkpointing:
                 continue
             # LevitForImageClassificationWithTeacher supports inference-only
             if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                 continue
             _UpperCAmelCase				:    List[Any]											=       model_class(lowerCAmelCase_						)
             model.gradient_checkpointing_enable()
             model.to(lowerCAmelCase_						)
             model.train()
             _UpperCAmelCase				:    Optional[int]											=       self._prepare_for_class(lowerCAmelCase_			,      lowerCAmelCase_			,      return_labels=lowerCAmelCase_						)
             _UpperCAmelCase				:    Any											=       model(**lowerCAmelCase_						).loss
             loss.backward()





     def 					__lowerCAmelCase      (   self						)				->   Any:
         _UpperCAmelCase				:    Union[str, Any]											=       self.model_tester.prepare_config_and_inputs_for_common()

         _UpperCAmelCase				:    Tuple											=       [
             {"title": "multi_label_classification", "num_labels": 2, "dtype": torch.float},
             {"title": "single_label_classification", "num_labels": 1, "dtype": torch.long},
             {"title": "regression", "num_labels": 1, "dtype": torch.float},
         ]

         for model_class in self.all_model_classes:
             if (
                 model_class
                 not in [
                     *get_values(lowerCAmelCase_						),
                 ]
                 or model_class.__name__ == "LevitForImageClassificationWithTeacher"
             ):
                 continue

             for problem_type in problem_types:
                 with self.subTest(msg=f'Testing {model_class} with {problem_type["title"]}'						):
                     _UpperCAmelCase				:    int											=       problem_type["title"]
                     _UpperCAmelCase				:    int											=       problem_type["num_labels"]

                     _UpperCAmelCase				:    Dict											=       model_class(lowerCAmelCase_						)
                     model.to(lowerCAmelCase_						)
                     model.train()

                     _UpperCAmelCase				:    int											=       self._prepare_for_class(lowerCAmelCase_			,      lowerCAmelCase_			,      return_labels=lowerCAmelCase_						)

                     if problem_type["num_labels"] > 1:
                         _UpperCAmelCase				:    Optional[Any]											=       inputs["labels"].unsqueeze(1						).repeat(1			,      problem_type['''num_labels''']						)

                     _UpperCAmelCase				:    str											=       inputs["labels"].to(problem_type['''dtype''']						)

                     # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
                     # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
                     # they have the same size." which is a symptom something in wrong for the regression problem.
                     # See https://github.com/huggingface/transformers/issues/11780
                     with warnings.catch_warnings(record=lowerCAmelCase_						) as warning_list:
                         _UpperCAmelCase				:    Dict											=       model(**lowerCAmelCase_						).loss
                     for w in warning_list:
                         if "Using a target size that is different to the input size" in str(w.message						):
                             raise ValueError(
                                 f'Something is going wrong in the regression problem: intercepted {w.message}'						)

                     loss.backward()





     @slow
     def 					__lowerCAmelCase      (   self						)				->   str:
         for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _UpperCAmelCase				:    Optional[int]											=       LevitModel.from_pretrained(lowerCAmelCase_						)
             self.assertIsNotNone(lowerCAmelCase_						)





def 					lowerCamelCase_		():
    _UpperCAmelCase				:    Dict											=       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
    return image


@require_torch
@require_vision
class 				_UpperCAmelCase				(					unittest.TestCase ):





     '''simple docstring'''



     @cached_property
     def 					__lowerCAmelCase      (   self						)				->   Optional[Any]:
         return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)





     @slow
     def 					__lowerCAmelCase      (   self						)				->   str:
         _UpperCAmelCase				:    Optional[Any]											=       LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
             lowerCAmelCase_						)

         _UpperCAmelCase				:    Any											=       self.default_image_processor
         _UpperCAmelCase				:    Dict											=       prepare_img()
         _UpperCAmelCase				:    int											=       image_processor(images=lowerCAmelCase_			,      return_tensors='''pt'''						).to(lowerCAmelCase_						)

         # forward pass
         with torch.no_grad():
             _UpperCAmelCase				:    Union[str, Any]											=       model(**lowerCAmelCase_						)

         # verify the logits
         _UpperCAmelCase				:    Dict											=       torch.Size((1, 1_0_0_0)						)
         self.assertEqual(outputs.logits.shape			,      lowerCAmelCase_						)

         _UpperCAmelCase				:    Dict											=       torch.tensor([1.0_448, -0.3_745, -1.8_317]						).to(lowerCAmelCase_						)

         self.assertTrue(torch.allclose(outputs.logits[0, :3]			,      lowerCAmelCase_			,      atol=1E-4						)						)










"""simple docstring"""
import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


if TYPE_CHECKING:
			from ... import PreTrainedTokenizerBase, TensorType

lowerCamelCase_							      = logging.get_logger(__name__)







class      UpperCamelCase_			(__A	):
	__magic_name__       =							'''vision-encoder-decoder'''
	__magic_name__       =							True





	def __init__( self   :					Union[str, Any]      ,      **lowerCAmelCase_   :					List[Any]		)		->     Union[str, Any]:
				super().__init__(**lowerCAmelCase_		)
				if "encoder" not in kwargs or "decoder" not in kwargs:
							raise ValueError(
							    f"""A configuraton of type {self.model_type} cannot be instantiated because """
							    f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}"""		)

				UpperCAmelCase_	:					str     	=   kwargs.pop("encoder"		)
				UpperCAmelCase_	:					Dict     	=   encoder_config.pop("model_type"		)
				UpperCAmelCase_	:					List[Any]     	=   kwargs.pop("decoder"		)
				UpperCAmelCase_	:					Dict     	=   decoder_config.pop("model_type"		)

				UpperCAmelCase_	:					Union[str, Any]     	=   AutoConfig.for_model(lowerCAmelCase_      ,      **lowerCAmelCase_		)
				UpperCAmelCase_	:					List[str]     	=   AutoConfig.for_model(lowerCAmelCase_      ,      **lowerCAmelCase_		)
				UpperCAmelCase_	:					Tuple     	=   True





	@classmethod
	def 	_SCREAMING_SNAKE_CASE ( cls   :					List[str]      ,      lowerCAmelCase_   :					PretrainedConfig      ,      lowerCAmelCase_   :					PretrainedConfig      ,      **lowerCAmelCase_   :					Dict		)		->     PretrainedConfig:
				logger.info("Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"		)
				UpperCAmelCase_	:					Tuple     	=   True
				UpperCAmelCase_	:					str     	=   True

				return cls(encoder=encoder_config.to_dict()      ,      decoder=decoder_config.to_dict()      ,      **lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]		)		->     List[Any]:
				UpperCAmelCase_	:					Union[str, Any]     	=   copy.deepcopy(self.__dict__		)
				UpperCAmelCase_	:					List[str]     	=   self.encoder.to_dict()
				UpperCAmelCase_	:					List[Any]     	=   self.decoder.to_dict()
				UpperCAmelCase_	:					Any     	=   self.__class__.model_type
				return output







class      UpperCamelCase_			(__A	):
	__magic_name__       =							version.parse('''1.11'''	)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]		)		->     Mapping[str, Mapping[int, str]]:
				return OrderedDict(
				    [
				        ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
				    ]		)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     float:
				return 1e-4





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Mapping[str, Mapping[int, str]]:
				return OrderedDict({"last_hidden_state": {0: "batch", 1: "encoder_sequence"}}		)







class      UpperCamelCase_			(__A	):





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     Mapping[str, Mapping[int, str]]:
				UpperCAmelCase_	:					List[Any]     	=   OrderedDict()
				UpperCAmelCase_	:					int     	=   {0: "batch", 1: "past_decoder_sequence + sequence"}
				UpperCAmelCase_	:					Dict     	=   {0: "batch", 1: "past_decoder_sequence + sequence"}
				UpperCAmelCase_	:					Union[str, Any]     	=   {0: "batch", 1: "encoder_sequence"}

				return common_inputs





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]      ,      lowerCAmelCase_   :					"PreTrainedTokenizerBase"      ,      lowerCAmelCase_   :					int = -1      ,      lowerCAmelCase_   :					int = -1      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					Optional["TensorType"] = None      ,      )		->     Mapping[str, Any]:
				import torch

				UpperCAmelCase_	:					Optional[int]     	=   OrderedDict()

				UpperCAmelCase_	:					Any     	=   super().generate_dummy_inputs(
				    lowerCAmelCase_      ,      batch_size=lowerCAmelCase_      ,      seq_length=lowerCAmelCase_      ,      is_pair=lowerCAmelCase_      ,      framework=lowerCAmelCase_		)

				UpperCAmelCase_	,      UpperCAmelCase_	:					Optional[Any]     	=   dummy_input["input_ids"].shape
				UpperCAmelCase_	:					List[str]     	=   (batch, encoder_sequence, self._config.encoder_hidden_size)
				UpperCAmelCase_	:					List[str]     	=   dummy_input.pop("input_ids"		)
				UpperCAmelCase_	:					List[str]     	=   dummy_input.pop("attention_mask"		)
				UpperCAmelCase_	:					List[Any]     	=   torch.zeros(lowerCAmelCase_		)

				return common_inputs







class      UpperCamelCase_			(__A	):





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     None:
				pass





	def 	_SCREAMING_SNAKE_CASE ( self   :					Any      ,      lowerCAmelCase_   :					PretrainedConfig		)		->     OnnxConfig:
				return VisionEncoderDecoderEncoderOnnxConfig(lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]      ,      lowerCAmelCase_   :					PretrainedConfig      ,      lowerCAmelCase_   :					PretrainedConfig      ,      lowerCAmelCase_   :					str = "default"		)		->     OnnxConfig:
				UpperCAmelCase_	:					Optional[int]     	=   encoder_config.hidden_size
				return VisionEncoderDecoderDecoderOnnxConfig(lowerCAmelCase_      ,      lowerCAmelCase_		)



