


"""simple docstring"""


import tempfile
import unittest

from make_student import create_student_by_copying_alternating_layers

from transformers import AutoConfig
from transformers.file_utils import cached_property
from transformers.testing_utils import require_torch


a_       							=    "sshleifer/bart-tiny-random"
a_       							=    "patrickvonplaten/t5-tiny-random"
@require_torch
class snake_case      (  unittest.TestCase):







		@cached_property
		def  a_ (					self      :       str		)       ->						Union[str, Any]:





						'''simple docstring'''







						return AutoConfig.from_pretrained(a__		)







		def  a_ (					self      :       Optional[Any]		)       ->						Dict:





						'''simple docstring'''







						_A  ,		*_A					  =			create_student_by_copying_alternating_layers(a__    ,   tempfile.mkdtemp()    ,   e=1    ,   d=1		)
						self.assertEqual(student.config.num_hidden_layers    ,   1		)







		def  a_ (					self      :       str		)       ->						Optional[Any]:





						'''simple docstring'''







						_A  ,		*_A					  =			create_student_by_copying_alternating_layers(a__    ,   tempfile.mkdtemp()    ,   e=1    ,   d=a__		)







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





						'''simple docstring'''







						_A  ,		*_A					  =			create_student_by_copying_alternating_layers(a__    ,   tempfile.mkdtemp()    ,   e=1    ,   d=a__		)
						self.assertEqual(student.config.encoder_layers    ,   1		)
						self.assertEqual(student.config.decoder_layers    ,   self.teacher_config.encoder_layers		)







		def  a_ (					self      :       Optional[Any]		)       ->						str:





						'''simple docstring'''







						_A  ,		*_A					  =			create_student_by_copying_alternating_layers(a__    ,   tempfile.mkdtemp()    ,   e=1    ,   d=1		)
						self.assertEqual(student.config.encoder_layers    ,   1		)
						self.assertEqual(student.config.decoder_layers    ,   1		)







		def  a_ (					self      :       str		)       ->						int:





						'''simple docstring'''







						with self.assertRaises(a__		):
										create_student_by_copying_alternating_layers(a__    ,   tempfile.mkdtemp()    ,   e=a__    ,   d=a__		)



"""simple docstring"""


import copy
import os
from typing import Union

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


a_       							=    logging.get_logger(__name__)

a_       							=    {
    "Salesforce/blip-vqa-base": "https://huggingface.co/Salesforce/blip-vqa-base/resolve/main/config.json",
    "Salesforce/blip-vqa-capfit-large": (
        "https://huggingface.co/Salesforce/blip-vqa-base-capfit/resolve/main/config.json"
    ),
    "Salesforce/blip-image-captioning-base": (
        "https://huggingface.co/Salesforce/blip-image-captioning-base/resolve/main/config.json"
    ),
    "Salesforce/blip-image-captioning-large": (
        "https://huggingface.co/Salesforce/blip-image-captioning-large/resolve/main/config.json"
    ),
    "Salesforce/blip-itm-base-coco": "https://huggingface.co/Salesforce/blip-itm-base-coco/resolve/main/config.json",
    "Salesforce/blip-itm-large-coco": "https://huggingface.co/Salesforce/blip-itm-large-coco/resolve/main/config.json",
    "Salesforce/blip-itm-base-flikr": "https://huggingface.co/Salesforce/blip-itm-base-flikr/resolve/main/config.json",
    "Salesforce/blip-itm-large-flikr": (
        "https://huggingface.co/Salesforce/blip-itm-large-flikr/resolve/main/config.json"
    ),
}
class snake_case      (  _UpperCamelCase):
		__UpperCamelCase           =			'blip_text_model'







		def __init__(					self      :       int    ,   a__      :       List[str]=3_05_24    ,   a__      :       List[str]=7_68    ,   a__      :       List[Any]=7_68    ,   a__      :       int=30_72    ,   a__      :       List[str]=7_68    ,   a__      :       Dict=12    ,   a__      :       Optional[int]=8    ,   a__      :       Optional[Any]=5_12    ,   a__      :       List[Any]="gelu"    ,   a__      :       Optional[Any]=1E-1_2    ,   a__      :       Any=0.0    ,   a__      :       int=0.0    ,   a__      :       Dict=0.0_2    ,   a__      :       Optional[Any]=3_05_22    ,   a__      :       Any=2    ,   a__      :       int=0    ,   a__      :       Union[str, Any]=1_02    ,   a__      :       Tuple=True    ,   a__      :       Optional[int]=True    ,   **a__      :       Any    ,   )       ->						List[Any]:





						'''simple docstring'''







						super().__init__(
						    pad_token_id=a__    ,   bos_token_id=a__    ,   eos_token_id=a__    ,   sep_token_id=a__    ,   **a__    ,   )

						_A					  =			vocab_size
						_A					  =			hidden_size
						_A					  =			encoder_hidden_size
						_A					  =			intermediate_size
						_A					  =			projection_dim
						_A					  =			hidden_dropout_prob
						_A					  =			num_hidden_layers
						_A					  =			num_attention_heads
						_A					  =			max_position_embeddings
						_A					  =			layer_norm_eps
						_A					  =			hidden_act
						_A					  =			initializer_range
						_A					  =			attention_probs_dropout_prob
						_A					  =			is_decoder
						_A					  =			use_cache







		@classmethod
		def  a_ (					cls      :       Optional[Any]    ,   a__      :       Union[str, os.PathLike]    ,   **a__      :       Optional[Any]		)       ->						"PretrainedConfig":





						'''simple docstring'''







						cls._set_token_in_kwargs(a__		)

						_A  ,		_A					  =			cls.get_config_dict(a__    ,   **a__		)

						# get the text config dict if we are loading from BlipConfig
						if config_dict.get("model_type"		) == "blip":
										_A					  =			config_dict["text_config"]

						if "model_type" in config_dict and hasattr(cls    ,   "model_type"		) and config_dict["model_type"] != cls.model_type:
										logger.warning(
										    F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
										    F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""		)

						return cls.from_dict(a__    ,   **a__		)





class snake_case      (  _UpperCamelCase):
		__UpperCamelCase           =			'blip_vision_model'







		def __init__(					self      :       Optional[Any]    ,   a__      :       Any=7_68    ,   a__      :       List[str]=30_72    ,   a__      :       str=5_12    ,   a__      :       Any=12    ,   a__      :       int=12    ,   a__      :       int=3_84    ,   a__      :       Tuple=16    ,   a__      :       str="gelu"    ,   a__      :       Tuple=1E-5    ,   a__      :       List[str]=0.0    ,   a__      :       List[Any]=1E-1_0    ,   **a__      :       int    ,   )       ->						List[str]:





						'''simple docstring'''







						super().__init__(**a__		)

						_A					  =			hidden_size
						_A					  =			intermediate_size
						_A					  =			projection_dim
						_A					  =			num_hidden_layers
						_A					  =			num_attention_heads
						_A					  =			patch_size
						_A					  =			image_size
						_A					  =			initializer_range
						_A					  =			attention_dropout
						_A					  =			layer_norm_eps
						_A					  =			hidden_act







		@classmethod
		def  a_ (					cls      :       Any    ,   a__      :       Union[str, os.PathLike]    ,   **a__      :       int		)       ->						"PretrainedConfig":





						'''simple docstring'''







						cls._set_token_in_kwargs(a__		)

						_A  ,		_A					  =			cls.get_config_dict(a__    ,   **a__		)

						# get the vision config dict if we are loading from BlipConfig
						if config_dict.get("model_type"		) == "blip":
										_A					  =			config_dict["vision_config"]

						if "model_type" in config_dict and hasattr(cls    ,   "model_type"		) and config_dict["model_type"] != cls.model_type:
										logger.warning(
										    F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
										    F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""		)

						return cls.from_dict(a__    ,   **a__		)





class snake_case      (  _UpperCamelCase):
		__UpperCamelCase           =			'blip'
		__UpperCamelCase           =			True







		def __init__(					self      :       List[Any]    ,   a__      :       Optional[int]=None    ,   a__      :       str=None    ,   a__      :       List[str]=5_12    ,   a__      :       Any=2.6_5_9_2    ,   a__      :       str=2_56    ,   **a__      :       Optional[int]    ,   )       ->						Dict:





						'''simple docstring'''







						super().__init__(**a__		)

						if text_config is None:
										_A					  =			{}
										logger.info("`text_config` is `None`. Initializing the `BlipTextConfig` with default values."		)

						if vision_config is None:
										_A					  =			{}
										logger.info("`vision_config` is `None`. Initializing the `BlipVisionConfig` with default values."		)

						_A					  =			BlipTextConfig(**a__		)
						_A					  =			BlipVisionConfig(**a__		)

						_A					  =			self.vision_config.hidden_size

						_A					  =			projection_dim
						_A					  =			logit_scale_init_value
						_A					  =			1.0
						_A					  =			0.0_2
						_A					  =			image_text_hidden_size







		@classmethod
		def  a_ (					cls      :       Tuple    ,   a__      :       BlipTextConfig    ,   a__      :       BlipVisionConfig    ,   **a__      :       Optional[int]		)       ->						str:





						'''simple docstring'''







						return cls(text_config=text_config.to_dict()    ,   vision_config=vision_config.to_dict()    ,   **a__		)







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





						'''simple docstring'''







						_A					  =			copy.deepcopy(self.__dict__		)
						_A					  =			self.text_config.to_dict()
						_A					  =			self.vision_config.to_dict()
						_A					  =			self.__class__.model_type
						return output