

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..bit import BitConfig


UpperCAmelCase_							:					List[str]		 =   logging.get_logger(__name__)

UpperCAmelCase_							:					Optional[Any]		 =   {
    '''Intel/dpt-large''': '''https://huggingface.co/Intel/dpt-large/resolve/main/config.json''',
    # See all DPT models at https://huggingface.co/models?filter=dpt
}






class      lowerCamelCase_      (	_lowercase	):
	_lowercase		:   Tuple     					=				'''dpt'''




	def __init__(     self						:     Tuple					,      __A						:     int=768					,      __A						:     List[str]=12					,      __A						:     Tuple=12					,      __A						:     List[str]=3072					,      __A						:     List[str]="gelu"					,      __A						:     str=0.0					,      __A						:     Optional[Any]=0.0					,      __A						:     List[str]=0.0_2					,      __A						:     Dict=1e-1_2					,      __A						:     List[Any]=384					,      __A						:     Dict=16					,      __A						:     Union[str, Any]=3					,      __A						:     Any=False					,      __A						:     Tuple=True					,      __A						:     List[Any]=[2, 5, 8, 11]					,      __A						:     Union[str, Any]="project"					,      __A						:     Tuple=[4, 2, 1, 0.5]					,      __A						:     Any=[96, 192, 384, 768]					,      __A						:     Dict=256					,      __A						:     Optional[int]=-1					,      __A						:     Any=False					,      __A						:     Dict=True					,      __A						:     Optional[int]=0.4					,      __A						:     Any=255					,      __A						:     Any=0.1					,      __A						:     Dict=[1, 1024, 24, 24]					,      __A						:     Dict=[0, 1]					,      __A						:     int=None					,      **__A						:     Dict					,      ):
		super().__init__(**__A							)

		__A :			List[str]		    =			hidden_size
		__A :			List[Any]		    =			is_hybrid

		if self.is_hybrid:
			if backbone_config is None:
				logger.info("""Initializing the config with a `BiT` backbone."""							)
				__A :			Union[str, Any]		    =			{
				    """global_padding""": """same""",
				    """layer_type""": """bottleneck""",
				    """depths""": [3, 4, 9],
				    """out_features""": ["""stage1""", """stage2""", """stage3"""],
				    """embedding_dynamic_padding""": True,
				}
				__A :			List[str]		    =			BitConfig(**__A							)
			elif isinstance(__A					,      __A							):
				logger.info("""Initializing the config with a `BiT` backbone."""							)
				__A :			int		    =			BitConfig(**__A							)
			elif isinstance(__A					,      __A							):
				__A :			Optional[Any]		    =			backbone_config
			else:
				raise ValueError(
				    F"""backbone_config must be a dictionary or a `PretrainedConfig`, got {backbone_config.__class__}."""							)

			__A :			Optional[Any]		    =			backbone_featmap_shape
			__A :			Optional[int]		    =			neck_ignore_stages

			if readout_type != "project":
				raise ValueError("""Readout type must be 'project' when using `DPT-hybrid` mode."""							)
		else:
			__A :			str		    =			None
			__A :			Union[str, Any]		    =			None
			__A :			List[str]		    =			[]

		__A :			Union[str, Any]		    =			num_hidden_layers
		__A :			Dict		    =			num_attention_heads
		__A :			Union[str, Any]		    =			intermediate_size
		__A :			Dict		    =			hidden_act
		__A :			Tuple		    =			hidden_dropout_prob
		__A :			Optional[int]		    =			attention_probs_dropout_prob
		__A :			Optional[int]		    =			initializer_range
		__A :			Optional[int]		    =			layer_norm_eps
		__A :			List[str]		    =			image_size
		__A :			Optional[int]		    =			patch_size
		__A :			int		    =			num_channels
		__A :			Tuple		    =			qkv_bias
		__A :			Tuple		    =			backbone_out_indices
		if readout_type not in ["ignore", "add", "project"]:
			raise ValueError("""Readout_type must be one of ['ignore', 'add', 'project']"""							)
		__A :			Optional[int]		    =			readout_type
		__A :			List[str]		    =			reassemble_factors
		__A :			Dict		    =			neck_hidden_sizes
		__A :			Dict		    =			fusion_hidden_size
		__A :			Dict		    =			head_in_index
		__A :			Dict		    =			use_batch_norm_in_fusion_residual
		# auxiliary head attributes (semantic segmentation)
		__A :			int		    =			use_auxiliary_head
		__A :			List[Any]		    =			auxiliary_loss_weight
		__A :			List[Any]		    =			semantic_loss_ignore_index
		__A :			List[str]		    =			semantic_classifier_dropout




	def        lowerCAmelCase_       (     self						:     Union[str, Any]							):
		__A :			List[Any]		    =			copy.deepcopy(self.__dict__							)

		if output["backbone_config"] is not None:
			__A :			Dict		    =			self.backbone_config.to_dict()

		__A :			Optional[int]		    =			self.__class__.model_type
		return output








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


UpperCAmelCase_							:					Optional[Any]		 =   {
    '''configuration_wav2vec2''': ['''WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Wav2Vec2Config'''],
    '''feature_extraction_wav2vec2''': ['''Wav2Vec2FeatureExtractor'''],
    '''processing_wav2vec2''': ['''Wav2Vec2Processor'''],
    '''tokenization_wav2vec2''': ['''Wav2Vec2CTCTokenizer''', '''Wav2Vec2Tokenizer'''],
}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					Optional[Any]		 =   [
			    '''WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''Wav2Vec2ForAudioFrameClassification''',
			    '''Wav2Vec2ForCTC''',
			    '''Wav2Vec2ForMaskedLM''',
			    '''Wav2Vec2ForPreTraining''',
			    '''Wav2Vec2ForSequenceClassification''',
			    '''Wav2Vec2ForXVector''',
			    '''Wav2Vec2Model''',
			    '''Wav2Vec2PreTrainedModel''',
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					List[Any]		 =   [
			    '''TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TFWav2Vec2ForCTC''',
			    '''TFWav2Vec2Model''',
			    '''TFWav2Vec2PreTrainedModel''',
			    '''TFWav2Vec2ForSequenceClassification''',
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					Dict		 =   [
			    '''FlaxWav2Vec2ForCTC''',
			    '''FlaxWav2Vec2ForPreTraining''',
			    '''FlaxWav2Vec2Model''',
			    '''FlaxWav2Vec2PreTrainedModel''',
			]


if TYPE_CHECKING:
			from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
			from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
			from .processing_wavaveca import WavaVecaProcessor
			from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_wavaveca import (
						    WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    WavaVecaForAudioFrameClassification,
						    WavaVecaForCTC,
						    WavaVecaForMaskedLM,
						    WavaVecaForPreTraining,
						    WavaVecaForSequenceClassification,
						    WavaVecaForXVector,
						    WavaVecaModel,
						    WavaVecaPreTrainedModel,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_wavaveca import (
						    TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFWavaVecaForCTC,
						    TFWavaVecaForSequenceClassification,
						    TFWavaVecaModel,
						    TFWavaVecaPreTrainedModel,
						)

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_wavaveca import (
						    FlaxWavaVecaForCTC,
						    FlaxWavaVecaForPreTraining,
						    FlaxWavaVecaModel,
						    FlaxWavaVecaPreTrainedModel,
						)


else:
			import sys

			UpperCAmelCase_							:					Optional[Any]		 =   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





