


'''simple docstring'''



from math import ceil






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Optional[int]						,      _SCREAMING_SNAKE_CASE      :   int   ):
					__a			:       str					    =  list(range(0						,      _SCREAMING_SNAKE_CASE   )   )

					__a			:       Union[str, Any]					    =  [item for sublist in list(device_map.values()   ) for item in sublist]

					# Duplicate check
					__a			:       int					    =  []
					for i in device_map_blocks:
										if device_map_blocks.count(_SCREAMING_SNAKE_CASE   ) > 1 and i not in duplicate_blocks:
															duplicate_blocks.append(_SCREAMING_SNAKE_CASE   )
    # Missing blocks
					__a			:       int					    =  [i for i in blocks if i not in device_map_blocks]
					__a			:       List[Any]					    =  [i for i in device_map_blocks if i not in blocks]

					if len(_SCREAMING_SNAKE_CASE   ) != 0:
										raise ValueError(
										    'Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device.'
										    ' These attention blocks were specified more than once: ' + str(_SCREAMING_SNAKE_CASE   )   )
					if len(_SCREAMING_SNAKE_CASE   ) != 0:
										raise ValueError(
										    'There are attention blocks for this model that are not specified in the device_map. Add these attention '
										    'blocks to a device on the device_map: ' + str(_SCREAMING_SNAKE_CASE   )   )
					if len(_SCREAMING_SNAKE_CASE   ) != 0:
										raise ValueError(
										    'The device_map contains more attention blocks than this model has. Remove these from the device_map:'
										    + str(_SCREAMING_SNAKE_CASE   )   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[str]						,      _SCREAMING_SNAKE_CASE      :   Optional[int]   ):
					__a			:       Union[str, Any]					    =  list(range(_SCREAMING_SNAKE_CASE   )   )
					__a			:       Tuple					    =  int(ceil(n_layers / len(_SCREAMING_SNAKE_CASE   )   )   )
					__a			:       Dict					    =  [layers[i : i + n_blocks] for i in range(0						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )]

					return dict(zip(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )   )







'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__lowercase	:						str       =	{
    'configuration_data2vec_audio': ['DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Data2VecAudioConfig'],
    'configuration_data2vec_text': [
        'DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecTextConfig',
        'Data2VecTextOnnxConfig',
    ],
    'configuration_data2vec_vision': [
        'DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecVisionConfig',
        'Data2VecVisionOnnxConfig',
    ],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__lowercase	:						str       =	[
	    'DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'Data2VecAudioForAudioFrameClassification',
	    'Data2VecAudioForCTC',
	    'Data2VecAudioForSequenceClassification',
	    'Data2VecAudioForXVector',
	    'Data2VecAudioModel',
	    'Data2VecAudioPreTrainedModel',
	]
	__lowercase	:						Tuple       =	[
	    'DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'Data2VecTextForCausalLM',
	    'Data2VecTextForMaskedLM',
	    'Data2VecTextForMultipleChoice',
	    'Data2VecTextForQuestionAnswering',
	    'Data2VecTextForSequenceClassification',
	    'Data2VecTextForTokenClassification',
	    'Data2VecTextModel',
	    'Data2VecTextPreTrainedModel',
	]
	__lowercase	:						Dict       =	[
	    'DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'Data2VecVisionForImageClassification',
	    'Data2VecVisionForMaskedImageModeling',
	    'Data2VecVisionForSemanticSegmentation',
	    'Data2VecVisionModel',
	    'Data2VecVisionPreTrainedModel',
	]

if is_tf_available():
	__lowercase	:						Optional[Any]       =	[
	    'TFData2VecVisionForImageClassification',
	    'TFData2VecVisionForSemanticSegmentation',
	    'TFData2VecVisionModel',
	    'TFData2VecVisionPreTrainedModel',
	]

if TYPE_CHECKING:
	from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
	from .configuration_dataavec_text import (
	    DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    DataaVecTextConfig,
	    DataaVecTextOnnxConfig,
	)
	from .configuration_dataavec_vision import (
	    DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    DataaVecVisionConfig,
	    DataaVecVisionOnnxConfig,
	)

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_dataavec_audio import (
		    DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
		    DataaVecAudioForAudioFrameClassification,
		    DataaVecAudioForCTC,
		    DataaVecAudioForSequenceClassification,
		    DataaVecAudioForXVector,
		    DataaVecAudioModel,
		    DataaVecAudioPreTrainedModel,
		)
		from .modeling_dataavec_text import (
		    DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    DataaVecTextForCausalLM,
		    DataaVecTextForMaskedLM,
		    DataaVecTextForMultipleChoice,
		    DataaVecTextForQuestionAnswering,
		    DataaVecTextForSequenceClassification,
		    DataaVecTextForTokenClassification,
		    DataaVecTextModel,
		    DataaVecTextPreTrainedModel,
		)
		from .modeling_dataavec_vision import (
		    DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
		    DataaVecVisionForImageClassification,
		    DataaVecVisionForMaskedImageModeling,
		    DataaVecVisionForSemanticSegmentation,
		    DataaVecVisionModel,
		    DataaVecVisionPreTrainedModel,
		)
	if is_tf_available():
		from .modeling_tf_dataavec_vision import (
		    TFDataaVecVisionForImageClassification,
		    TFDataaVecVisionForSemanticSegmentation,
		    TFDataaVecVisionModel,
		    TFDataaVecVisionPreTrainedModel,
		)

else:
	import sys

	__lowercase	:						int       =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



