
import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class        _UpperCamelCase				(					_A     ,       unittest.TestCase  ):






			'''simple docstring'''

			__UpperCamelCase      :						List[Any]					      = UnCLIPImageVariationPipeline
			__UpperCamelCase      :						str					      = IMAGE_VARIATION_PARAMS - {"""height""", """width""", """guidance_scale"""}
			__UpperCamelCase      :						List[Any]					      = IMAGE_VARIATION_BATCH_PARAMS

			__UpperCamelCase      :						Optional[Any]					      = [
			    """generator""",
			    """return_dict""",
			    """decoder_num_inference_steps""",
			    """super_res_num_inference_steps""",
			]
			__UpperCamelCase      :						Optional[Any]					      = False

			@property
			def       lowerCAmelCase__	(       self :       List[Any]      ):
							return 32

			@property
			def       lowerCAmelCase__	(       self :       int      ):
							return 32

			@property
			def       lowerCAmelCase__	(       self :       Tuple      ):
							return self.time_input_dim

			@property
			def       lowerCAmelCase__	(       self :       List[Any]      ):
							return self.time_input_dim * 4

			@property
			def       lowerCAmelCase__	(       self :       Union[str, Any]      ):
							return 100

			@property
			def       lowerCAmelCase__	(       self :       Union[str, Any]      ):
							UpperCamelCase_:							List[Any]	=						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""      )
							return tokenizer

			@property
			def       lowerCAmelCase__	(       self :       Optional[Any]      ):
							torch.manual_seed(0      )
							UpperCamelCase_:							Union[str, Any]	=						CLIPTextConfig(
							    bos_token_id=0						,	eos_token_id=2						,	hidden_size=self.text_embedder_hidden_size						,	projection_dim=self.text_embedder_hidden_size						,	intermediate_size=37						,	layer_norm_eps=1e-05						,	num_attention_heads=4						,	num_hidden_layers=5						,	pad_token_id=1						,	vocab_size=1000						,	)
							return CLIPTextModelWithProjection(snake_case_      )

			@property
			def       lowerCAmelCase__	(       self :       List[Any]      ):
							torch.manual_seed(0      )
							UpperCamelCase_:							Optional[int]	=						CLIPVisionConfig(
							    hidden_size=self.text_embedder_hidden_size						,	projection_dim=self.text_embedder_hidden_size						,	num_hidden_layers=5						,	num_attention_heads=4						,	image_size=32						,	intermediate_size=37						,	patch_size=1						,	)
							return CLIPVisionModelWithProjection(snake_case_      )

			@property
			def       lowerCAmelCase__	(       self :       Optional[Any]      ):
							torch.manual_seed(0      )

							UpperCamelCase_:							int	=						{
							    """clip_embeddings_dim""": self.text_embedder_hidden_size,
							    """time_embed_dim""": self.time_embed_dim,
							    """cross_attention_dim""": self.cross_attention_dim,
							}

							UpperCamelCase_:							int	=						UnCLIPTextProjModel(**snake_case_      )
							return model

			@property
			def       lowerCAmelCase__	(       self :       Optional[int]      ):
							torch.manual_seed(0      )

							UpperCamelCase_:							List[Any]	=						{
							    """sample_size""": 32,
							    # RGB in channels
							    """in_channels""": 3,
							    # Out channels is double in channels because predicts mean and variance
							    """out_channels""": 6,
							    """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
							    """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
							    """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
							    """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
							    """layers_per_block""": 1,
							    """cross_attention_dim""": self.cross_attention_dim,
							    """attention_head_dim""": 4,
							    """resnet_time_scale_shift""": """scale_shift""",
							    """class_embed_type""": """identity""",
							}

							UpperCamelCase_:							str	=						UNetaDConditionModel(**snake_case_      )
							return model

			@property
			def       lowerCAmelCase__	(       self :       int      ):
							return {
							    "sample_size": 64,
							    "layers_per_block": 1,
							    "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
							    "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
							    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
							    "in_channels": 6,
							    "out_channels": 3,
							}

			@property
			def       lowerCAmelCase__	(       self :       int      ):
							torch.manual_seed(0      )

							UpperCamelCase_:							Dict	=						UNetaDModel(**self.dummy_super_res_kwargs      )
							return model

			@property
			def       lowerCAmelCase__	(       self :       List[Any]      ):
							# seeded differently to get different unet than `self.dummy_super_res_first`
							torch.manual_seed(1      )

							UpperCamelCase_:							Dict	=						UNetaDModel(**self.dummy_super_res_kwargs      )
							return model

			def       lowerCAmelCase__	(       self :       str      ):
							UpperCamelCase_:							List[str]	=						self.dummy_decoder
							UpperCamelCase_:							str	=						self.dummy_text_proj
							UpperCamelCase_:							List[str]	=						self.dummy_text_encoder
							UpperCamelCase_:							int	=						self.dummy_tokenizer
							UpperCamelCase_:							Tuple	=						self.dummy_super_res_first
							UpperCamelCase_:							Dict	=						self.dummy_super_res_last

							UpperCamelCase_:							str	=						UnCLIPScheduler(
							    variance_type="""learned_range"""						,	prediction_type="""epsilon"""						,	num_train_timesteps=1000						,	)

							UpperCamelCase_:							List[Any]	=						UnCLIPScheduler(
							    variance_type="""fixed_small_log"""						,	prediction_type="""epsilon"""						,	num_train_timesteps=1000						,	)

							UpperCamelCase_:							List[str]	=						CLIPImageProcessor(crop_size=32						,	size=32      )

							UpperCamelCase_:							Dict	=						self.dummy_image_encoder

							return {
							    "decoder": decoder,
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "text_proj": text_proj,
							    "feature_extractor": feature_extractor,
							    "image_encoder": image_encoder,
							    "super_res_first": super_res_first,
							    "super_res_last": super_res_last,
							    "decoder_scheduler": decoder_scheduler,
							    "super_res_scheduler": super_res_scheduler,
							}

			def       lowerCAmelCase__	(       self :       List[str]						,	snake_case_ :       Any						,	snake_case_ :       Optional[int]=0						,	snake_case_ :       Optional[Any]=True      ):
							UpperCamelCase_:							int	=						floats_tensor((1, 3, 32, 32)						,	rng=random.Random(snake_case_      )      ).to(snake_case_      )
							if str(snake_case_      ).startswith("""mps"""      ):
											UpperCamelCase_:							int	=						torch.manual_seed(snake_case_      )
							else:
											UpperCamelCase_:							Union[str, Any]	=						torch.Generator(device=snake_case_      ).manual_seed(snake_case_      )

							if pil_image:
											UpperCamelCase_:							Optional[Any]	=						input_image * 0.5 + 0.5
											UpperCamelCase_:							Tuple	=						input_image.clamp(0						,	1      )
											UpperCamelCase_:							Tuple	=						input_image.cpu().permute(0						,	2						,	3						,	1      ).float().numpy()
											UpperCamelCase_:							Union[str, Any]	=						DiffusionPipeline.numpy_to_pil(snake_case_      )[0]

							return {
							    "image": input_image,
							    "generator": generator,
							    "decoder_num_inference_steps": 2,
							    "super_res_num_inference_steps": 2,
							    "output_type": "np",
							}

			def       lowerCAmelCase__	(       self :       Dict      ):
							UpperCamelCase_:							Optional[int]	=						"""cpu"""

							UpperCamelCase_:							Optional[Any]	=						self.get_dummy_components()

							UpperCamelCase_:							List[Any]	=						self.pipeline_class(**snake_case_      )
							UpperCamelCase_:							List[Any]	=						pipe.to(snake_case_      )

							pipe.set_progress_bar_config(disable=snake_case_      )

							UpperCamelCase_:							int	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )

							UpperCamelCase_:							Tuple	=						pipe(**snake_case_      )
							UpperCamelCase_:							List[Any]	=						output.images

							UpperCamelCase_:							str	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )

							UpperCamelCase_:							Dict	=						pipe(
							    **snake_case_						,	return_dict=snake_case_						,	)[0]

							UpperCamelCase_:							str	=						image[0, -3:, -3:, -1]
							UpperCamelCase_:							Dict	=						image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							UpperCamelCase_:							Union[str, Any]	=						np.array(
							    [
							        0.9997,
							        0.0002,
							        0.9997,
							        0.9997,
							        0.9969,
							        0.0023,
							        0.9997,
							        0.9969,
							        0.9970,
							    ]      )

							assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
							assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1e-2

			def       lowerCAmelCase__	(       self :       Optional[Any]      ):
							UpperCamelCase_:							Optional[int]	=						"""cpu"""

							UpperCamelCase_:							List[str]	=						self.get_dummy_components()

							UpperCamelCase_:							Optional[Any]	=						self.pipeline_class(**snake_case_      )
							UpperCamelCase_:							Optional[int]	=						pipe.to(snake_case_      )

							pipe.set_progress_bar_config(disable=snake_case_      )

							UpperCamelCase_:							List[str]	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )

							UpperCamelCase_:							Optional[int]	=						pipe(**snake_case_      )
							UpperCamelCase_:							int	=						output.images

							UpperCamelCase_:							Tuple	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )

							UpperCamelCase_:							Optional[int]	=						pipe(
							    **snake_case_						,	return_dict=snake_case_						,	)[0]

							UpperCamelCase_:							int	=						image[0, -3:, -3:, -1]
							UpperCamelCase_:							Any	=						image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							UpperCamelCase_:							Optional[int]	=						np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971]      )

							assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
							assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1e-2

			def       lowerCAmelCase__	(       self :       Optional[Any]      ):
							UpperCamelCase_:							List[Any]	=						"""cpu"""

							UpperCamelCase_:							Tuple	=						self.get_dummy_components()

							UpperCamelCase_:							Dict	=						self.pipeline_class(**snake_case_      )
							UpperCamelCase_:							List[Any]	=						pipe.to(snake_case_      )

							pipe.set_progress_bar_config(disable=snake_case_      )

							UpperCamelCase_:							Union[str, Any]	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )
							UpperCamelCase_:							Tuple	=						[
							    pipeline_inputs["""image"""],
							    pipeline_inputs["""image"""],
							]

							UpperCamelCase_:							List[Any]	=						pipe(**snake_case_      )
							UpperCamelCase_:							Any	=						output.images

							UpperCamelCase_:							Optional[Any]	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )
							UpperCamelCase_:							Optional[Any]	=						[
							    tuple_pipeline_inputs["""image"""],
							    tuple_pipeline_inputs["""image"""],
							]

							UpperCamelCase_:							Optional[int]	=						pipe(
							    **snake_case_						,	return_dict=snake_case_						,	)[0]

							UpperCamelCase_:							Any	=						image[0, -3:, -3:, -1]
							UpperCamelCase_:							Optional[int]	=						image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (2, 64, 64, 3)

							UpperCamelCase_:							List[str]	=						np.array(
							    [
							        0.9997,
							        0.9989,
							        0.0008,
							        0.0021,
							        0.9960,
							        0.0018,
							        0.0014,
							        0.0002,
							        0.9933,
							    ]      )

							assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
							assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1e-2

			def       lowerCAmelCase__	(       self :       int      ):
							UpperCamelCase_:							List[Any]	=						torch.device("""cpu"""      )

							class        _UpperCamelCase				:






										'''simple docstring'''

										__UpperCamelCase      :						Optional[Any]					      = 1




							UpperCamelCase_:							Union[str, Any]	=						self.get_dummy_components()

							UpperCamelCase_:							int	=						self.pipeline_class(**snake_case_      )
							UpperCamelCase_:							Optional[Any]	=						pipe.to(snake_case_      )

							pipe.set_progress_bar_config(disable=snake_case_      )

							UpperCamelCase_:							List[Any]	=						torch.Generator(device=snake_case_      ).manual_seed(0      )
							UpperCamelCase_:							int	=						pipe.decoder.dtype
							UpperCamelCase_:							Optional[Any]	=						1

							UpperCamelCase_:							List[str]	=						(
							    batch_size,
							    pipe.decoder.config.in_channels,
							    pipe.decoder.config.sample_size,
							    pipe.decoder.config.sample_size,
							)
							UpperCamelCase_:							Any	=						pipe.prepare_latents(
							    snake_case_						,	dtype=snake_case_						,	device=snake_case_						,	generator=snake_case_						,	latents=snake_case_						,	scheduler=DummyScheduler()      )

							UpperCamelCase_:							Tuple	=						(
							    batch_size,
							    pipe.super_res_first.config.in_channels // 2,
							    pipe.super_res_first.config.sample_size,
							    pipe.super_res_first.config.sample_size,
							)
							UpperCamelCase_:							int	=						pipe.prepare_latents(
							    snake_case_						,	dtype=snake_case_						,	device=snake_case_						,	generator=snake_case_						,	latents=snake_case_						,	scheduler=DummyScheduler()      )

							UpperCamelCase_:							List[Any]	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )

							UpperCamelCase_:							Optional[int]	=						pipe(
							    **snake_case_						,	decoder_latents=snake_case_						,	super_res_latents=snake_case_      ).images

							UpperCamelCase_:							Optional[Any]	=						self.get_dummy_inputs(snake_case_						,	pil_image=snake_case_      )
							# Don't pass image, instead pass embedding
							UpperCamelCase_:							List[str]	=						pipeline_inputs.pop("""image"""      )
							UpperCamelCase_:							Optional[int]	=						pipe.image_encoder(snake_case_      ).image_embeds

							UpperCamelCase_:							Union[str, Any]	=						pipe(
							    **snake_case_						,	decoder_latents=snake_case_						,	super_res_latents=snake_case_						,	image_embeddings=snake_case_						,	).images

							# make sure passing text embeddings manually is identical
							assert np.abs(img_out_a - img_out_a      ).max() < 1e-4

			@skip_mps
			def       lowerCAmelCase__	(       self :       Tuple      ):
							UpperCamelCase_:							Optional[int]	=						torch_device == """cpu"""

							# Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
							UpperCamelCase_:							Any	=						1e-2

							self._test_attention_slicing_forward_pass(
							    test_max_difference=snake_case_						,	expected_max_diff=snake_case_      )

			@skip_mps
			def       lowerCAmelCase__	(       self :       Union[str, Any]      ):
							UpperCamelCase_:							Optional[int]	=						torch_device == """cpu"""
							UpperCamelCase_:							int	=						True
							UpperCamelCase_:							Dict	=						[
							    """decoder_num_inference_steps""",
							    """super_res_num_inference_steps""",
							]

							self._test_inference_batch_single_identical(
							    test_max_difference=snake_case_						,	relax_max_difference=snake_case_						,	additional_params_copy_to_batched_inputs=snake_case_						,	)

			def       lowerCAmelCase__	(       self :       str      ):
							UpperCamelCase_:							Any	=						[
							    """decoder_num_inference_steps""",
							    """super_res_num_inference_steps""",
							]

							if torch_device == "mps":
											# TODO: MPS errors with larger batch sizes
											UpperCamelCase_:							Optional[int]	=						[2, 3]
											self._test_inference_batch_consistent(
											    batch_sizes=snake_case_						,	additional_params_copy_to_batched_inputs=snake_case_						,	)
							else:
											self._test_inference_batch_consistent(
											    additional_params_copy_to_batched_inputs=snake_case_      )

			@skip_mps
			def       lowerCAmelCase__	(       self :       List[str]      ):
							return super().test_dict_tuple_outputs_equivalent()

			@skip_mps
			def       lowerCAmelCase__	(       self :       List[Any]      ):
							return super().test_save_load_local()




			@skip_mps
			def       lowerCAmelCase__	(       self :       Tuple      ):
							return super().test_save_load_optional_components()




@slow
@require_torch_gpu
class        _UpperCamelCase				(					unittest.TestCase  ):






			'''simple docstring'''

			def       lowerCAmelCase__	(       self :       Optional[Any]      ):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




			def       lowerCAmelCase__	(       self :       List[Any]      ):
							UpperCamelCase_:							Any	=						load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png"""      )
							UpperCamelCase_:							int	=						load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/unclip/karlo_v1_alpha_cat_variation_fp16.npy"""      )

							UpperCamelCase_:							Optional[Any]	=						UnCLIPImageVariationPipeline.from_pretrained(
							    """kakaobrain/karlo-v1-alpha-image-variations"""						,	torch_dtype=torch.floataa      )
							UpperCamelCase_:							Dict	=						pipeline.to(snake_case_      )
							pipeline.set_progress_bar_config(disable=snake_case_      )

							UpperCamelCase_:							Any	=						torch.Generator(device="""cpu"""      ).manual_seed(0      )
							UpperCamelCase_:							Union[str, Any]	=						pipeline(
							    snake_case_						,	generator=snake_case_						,	output_type="""np"""						,	)

							UpperCamelCase_:							str	=						output.images[0]

							assert image.shape == (256, 256, 3)

							assert_mean_pixel_difference(snake_case_						,	snake_case_						,	15      )








from typing import TYPE_CHECKING

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


lowerCamelCase_						: Optional[Any]         =  {
    """configuration_distilbert""": [
        """DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """DistilBertConfig""",
        """DistilBertOnnxConfig""",
    ],
    """tokenization_distilbert""": ["""DistilBertTokenizer"""],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: List[Any]         =  ["""DistilBertTokenizerFast"""]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: Optional[int]         =  [
							    """DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """DistilBertForMaskedLM""",
							    """DistilBertForMultipleChoice""",
							    """DistilBertForQuestionAnswering""",
							    """DistilBertForSequenceClassification""",
							    """DistilBertForTokenClassification""",
							    """DistilBertModel""",
							    """DistilBertPreTrainedModel""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: List[str]         =  [
							    """TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TFDistilBertForMaskedLM""",
							    """TFDistilBertForMultipleChoice""",
							    """TFDistilBertForQuestionAnswering""",
							    """TFDistilBertForSequenceClassification""",
							    """TFDistilBertForTokenClassification""",
							    """TFDistilBertMainLayer""",
							    """TFDistilBertModel""",
							    """TFDistilBertPreTrainedModel""",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: Dict         =  [
							    """FlaxDistilBertForMaskedLM""",
							    """FlaxDistilBertForMultipleChoice""",
							    """FlaxDistilBertForQuestionAnswering""",
							    """FlaxDistilBertForSequenceClassification""",
							    """FlaxDistilBertForTokenClassification""",
							    """FlaxDistilBertModel""",
							    """FlaxDistilBertPreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_distilbert import (
							    DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    DistilBertConfig,
							    DistilBertOnnxConfig,
							)
							from .tokenization_distilbert import DistilBertTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_distilbert_fast import DistilBertTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_distilbert import (
														    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DistilBertForMaskedLM,
														    DistilBertForMultipleChoice,
														    DistilBertForQuestionAnswering,
														    DistilBertForSequenceClassification,
														    DistilBertForTokenClassification,
														    DistilBertModel,
														    DistilBertPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_distilbert import (
														    TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFDistilBertForMaskedLM,
														    TFDistilBertForMultipleChoice,
														    TFDistilBertForQuestionAnswering,
														    TFDistilBertForSequenceClassification,
														    TFDistilBertForTokenClassification,
														    TFDistilBertMainLayer,
														    TFDistilBertModel,
														    TFDistilBertPreTrainedModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_distilbert import (
														    FlaxDistilBertForMaskedLM,
														    FlaxDistilBertForMultipleChoice,
														    FlaxDistilBertForQuestionAnswering,
														    FlaxDistilBertForSequenceClassification,
														    FlaxDistilBertForTokenClassification,
														    FlaxDistilBertModel,
														    FlaxDistilBertPreTrainedModel,
														)

else:
							import sys

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






