
"""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 				lowercase__(				__lowerCamelCase   ):
	'''simple docstring'''

	def   __lowerCAmelCase (						self    :List[str]					)							->			List[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= self.config_class(**self.inputs_dict					)
			self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_		, '''hidden_sizes'''					)					)
			self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_		, '''num_attention_heads'''					)					)





class 				lowercase__:
	'''simple docstring'''

	def __init__(						self    :Optional[Any]		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :int=13		, lowerCamelCase_    :str=64		, lowerCamelCase_    :Union[str, Any]=3		, lowerCamelCase_    :Optional[int]=3		, lowerCamelCase_    :str=2		, lowerCamelCase_    :Optional[int]=1		, lowerCamelCase_    :int=16		, lowerCamelCase_    :List[str]=[1_28, 2_56, 3_84]		, lowerCamelCase_    :Optional[int]=[4, 6, 8]		, lowerCamelCase_    :Tuple=[2, 3, 4]		, lowerCamelCase_    :Tuple=[16, 16, 16]		, lowerCamelCase_    :Tuple=0		, lowerCamelCase_    :List[Any]=[2, 2, 2]		, lowerCamelCase_    :Optional[Any]=[2, 2, 2]		, lowerCamelCase_    :str=0.0_2		, lowerCamelCase_    :Optional[Any]=True		, lowerCamelCase_    :List[Any]=True		, lowerCamelCase_    :Tuple=2		, )							->			Union[str, Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[int]				= parent
			SCREAMING_SNAKE_CASE       :     str				= batch_size
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= image_size
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= num_channels
			SCREAMING_SNAKE_CASE       :     List[str]				= kernel_size
			SCREAMING_SNAKE_CASE       :     int				= stride
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= padding
			SCREAMING_SNAKE_CASE       :     str				= hidden_sizes
			SCREAMING_SNAKE_CASE       :     int				= num_attention_heads
			SCREAMING_SNAKE_CASE       :     List[Any]				= depths
			SCREAMING_SNAKE_CASE       :     Any				= key_dim
			SCREAMING_SNAKE_CASE       :     int				= drop_path_rate
			SCREAMING_SNAKE_CASE       :     str				= patch_size
			SCREAMING_SNAKE_CASE       :     Tuple				= attention_ratio
			SCREAMING_SNAKE_CASE       :     int				= mlp_ratio
			SCREAMING_SNAKE_CASE       :     Dict				= initializer_range
			SCREAMING_SNAKE_CASE       :     Optional[int]				= [
			    ['''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],
			]
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= is_training
			SCREAMING_SNAKE_CASE       :     Tuple				= use_labels
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= num_labels
			SCREAMING_SNAKE_CASE       :     str				= initializer_range





	def   __lowerCAmelCase (						self    :Tuple					)							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

			SCREAMING_SNAKE_CASE       :     List[str]				= self.get_config()
			return config, pixel_values, labels





	def   __lowerCAmelCase (						self    :Optional[int]					)							->			List[str]:







			'''simple docstring'''




			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    :List[Any]		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :int					)							->			List[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= LevitModel(config=SCREAMING_SNAKE_CASE_					)
			model.to(SCREAMING_SNAKE_CASE_					)
			model.eval()
			SCREAMING_SNAKE_CASE       :     Any				= model(SCREAMING_SNAKE_CASE_					)
			SCREAMING_SNAKE_CASE       :     List[Any]				= (self.image_size, self.image_size)
			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     str				= image_size[0], image_size[1]
			for _ in range(4					):
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1					)
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= 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    :int		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :List[Any]		, lowerCamelCase_    :Union[str, Any]					)							->			Any:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= self.num_labels
			SCREAMING_SNAKE_CASE       :     str				= LevitForImageClassification(SCREAMING_SNAKE_CASE_					)
			model.to(SCREAMING_SNAKE_CASE_					)
			model.eval()
			SCREAMING_SNAKE_CASE       :     Tuple				= model(SCREAMING_SNAKE_CASE_		, labels=SCREAMING_SNAKE_CASE_					)
			self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.num_labels)					)







	def   __lowerCAmelCase (						self    :str					)							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= self.prepare_config_and_inputs()
			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     List[str]				= config_and_inputs
			SCREAMING_SNAKE_CASE       :     Optional[int]				= {'''pixel_values''': pixel_values}
			return config, inputs_dict





@require_torch
class 				lowercase__(				__lowerCamelCase		,						__lowerCamelCase		,						unittest.TestCase   ):
	'''simple docstring'''

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

	UpperCamelCase				=  False
	UpperCamelCase				=  False
	UpperCamelCase				=  False
	UpperCamelCase				=  False
	UpperCamelCase				=  False





	def   __lowerCAmelCase (						self    :Union[str, Any]					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= LevitModelTester(self					)
			SCREAMING_SNAKE_CASE       :     str				= ConfigTester(self		, config_class=SCREAMING_SNAKE_CASE_		, has_text_modality=SCREAMING_SNAKE_CASE_		, hidden_size=37					)





	def   __lowerCAmelCase (						self    :Dict					)							->			List[str]:







			'''simple docstring'''




			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    :Dict					)							->			Any:







			'''simple docstring'''




			return





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







			'''simple docstring'''




			pass





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







			'''simple docstring'''




			pass





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







			'''simple docstring'''




			pass





	def   __lowerCAmelCase (						self    :List[Any]					)							->			List[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     Optional[int]				= self.model_tester.prepare_config_and_inputs_for_common()

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

					SCREAMING_SNAKE_CASE       :     Any				= ['''pixel_values''']
					self.assertListEqual(arg_names[:1]		, SCREAMING_SNAKE_CASE_					)





	def   __lowerCAmelCase (						self    :Any					)							->			Optional[Any]:







			'''simple docstring'''




			def check_hidden_states_output(lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :int		, lowerCamelCase_    :str					):
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= model_class(SCREAMING_SNAKE_CASE_					)
					model.to(SCREAMING_SNAKE_CASE_					)
					model.eval()

					with torch.no_grad():
							SCREAMING_SNAKE_CASE       :     Tuple				= model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_		, SCREAMING_SNAKE_CASE_					)					)

					SCREAMING_SNAKE_CASE       :     int				= outputs.hidden_states

					SCREAMING_SNAKE_CASE       :     Optional[int]				= len(self.model_tester.depths					) + 1
					self.assertEqual(len(SCREAMING_SNAKE_CASE_					)		, SCREAMING_SNAKE_CASE_					)

					SCREAMING_SNAKE_CASE       :     Tuple				= (self.model_tester.image_size, self.model_tester.image_size)
					SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     Union[str, Any]				= image_size[0], image_size[1]
					for _ in range(4					):
							SCREAMING_SNAKE_CASE       :     int				= floor(
							    (
							        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
							        / self.model_tester.stride
							    )
							    + 1					)
							SCREAMING_SNAKE_CASE       :     str				= 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],
					    ]		, )

			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     str				= self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					SCREAMING_SNAKE_CASE       :     str				= True
					check_hidden_states_output(SCREAMING_SNAKE_CASE_		, SCREAMING_SNAKE_CASE_		, SCREAMING_SNAKE_CASE_					)

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

					check_hidden_states_output(SCREAMING_SNAKE_CASE_		, SCREAMING_SNAKE_CASE_		, SCREAMING_SNAKE_CASE_					)





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







			'''simple docstring'''




			pass





	def   __lowerCAmelCase (						self    :Dict		, lowerCamelCase_    :Dict		, lowerCamelCase_    :List[Any]		, lowerCamelCase_    :Any=False					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     str				= super()._prepare_for_class(SCREAMING_SNAKE_CASE_		, SCREAMING_SNAKE_CASE_		, return_labels=SCREAMING_SNAKE_CASE_					)

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

			return inputs_dict





	def   __lowerCAmelCase (						self    :int					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_					)





	def   __lowerCAmelCase (						self    :List[str]					)							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_					)





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







			'''simple docstring'''




			if not self.model_tester.is_training:
					return

			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     List[str]				= self.model_tester.prepare_config_and_inputs_for_common()
			SCREAMING_SNAKE_CASE       :     str				= True

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





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     List[Any]				= self.model_tester.prepare_config_and_inputs_for_common()
			if not self.model_tester.is_training:
					return

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= False
			SCREAMING_SNAKE_CASE       :     List[Any]				= True

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





	def   __lowerCAmelCase (						self    :List[str]					)							->			Optional[int]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     Tuple				= self.model_tester.prepare_config_and_inputs_for_common()

			SCREAMING_SNAKE_CASE       :     Any				= [
			    {'''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(SCREAMING_SNAKE_CASE_					),
					    ]
					    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
					):
							continue

					for problem_type in problem_types:
							with self.subTest(msg=f"Testing {model_class} with {problem_type['title']}"					):
									SCREAMING_SNAKE_CASE       :     List[str]				= problem_type['''title''']
									SCREAMING_SNAKE_CASE       :     Union[str, Any]				= problem_type['''num_labels''']

									SCREAMING_SNAKE_CASE       :     List[str]				= model_class(SCREAMING_SNAKE_CASE_					)
									model.to(SCREAMING_SNAKE_CASE_					)
									model.train()

									SCREAMING_SNAKE_CASE       :     str				= self._prepare_for_class(SCREAMING_SNAKE_CASE_		, SCREAMING_SNAKE_CASE_		, return_labels=SCREAMING_SNAKE_CASE_					)

									if problem_type["num_labels"] > 1:
											SCREAMING_SNAKE_CASE       :     str				= inputs['''labels'''].unsqueeze(1					).repeat(1		, problem_type['''num_labels''']					)

									SCREAMING_SNAKE_CASE       :     List[Any]				= 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=SCREAMING_SNAKE_CASE_					) as warning_list:
											SCREAMING_SNAKE_CASE       :     Optional[Any]				= model(**SCREAMING_SNAKE_CASE_					).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    :List[str]					)							->			List[Any]:







			'''simple docstring'''




			for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					SCREAMING_SNAKE_CASE       :     List[Any]				= LevitModel.from_pretrained(SCREAMING_SNAKE_CASE_					)
					self.assertIsNotNone(SCREAMING_SNAKE_CASE_					)





def 		__A						(   )->							Optional[Any]:




		'''simple docstring'''






		SCREAMING_SNAKE_CASE       :     str				= Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
		return image




@require_torch
@require_vision
class 				lowercase__(				unittest.TestCase   ):
	'''simple docstring'''

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







			'''simple docstring'''




			return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)







	@slow
	def   __lowerCAmelCase (						self    :str					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]					).to(
			    SCREAMING_SNAKE_CASE_					)

			SCREAMING_SNAKE_CASE       :     int				= self.default_image_processor
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= prepare_img()
			SCREAMING_SNAKE_CASE       :     Optional[int]				= image_processor(images=SCREAMING_SNAKE_CASE_		, return_tensors='''pt'''					).to(SCREAMING_SNAKE_CASE_					)

			# forward pass
			with torch.no_grad():
					SCREAMING_SNAKE_CASE       :     List[Any]				= model(**SCREAMING_SNAKE_CASE_					)

			# verify the logits
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= torch.Size((1, 10_00)					)
			self.assertEqual(outputs.logits.shape		, SCREAMING_SNAKE_CASE_					)

			SCREAMING_SNAKE_CASE       :     int				= torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]					).to(SCREAMING_SNAKE_CASE_					)

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







"""simple docstring"""






from typing import TYPE_CHECKING

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


lowerCamelCase__ :       Tuple						     =			{
    "configuration_mctct": ["MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP", "MCTCTConfig"],
    "feature_extraction_mctct": ["MCTCTFeatureExtractor"],
    "processing_mctct": ["MCTCTProcessor"],
}


try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase__ :       Union[str, Any]						     =			[
					    "MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "MCTCTForCTC",
					    "MCTCTModel",
					    "MCTCTPreTrainedModel",
					]


if TYPE_CHECKING:
					from .configuration_mctct import MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP, MCTCTConfig
					from .feature_extraction_mctct import MCTCTFeatureExtractor
					from .processing_mctct import MCTCTProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_mctct import MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST, MCTCTForCTC, MCTCTModel, MCTCTPreTrainedModel

else:
					import sys

					lowerCamelCase__ :       Tuple						     =			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





