




'''simple docstring'''





import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 torch import nn

		from transformers import (
		    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
		    MODEL_MAPPING,
		    DeiTForImageClassification,
		    DeiTForImageClassificationWithTeacher,
		    DeiTForMaskedImageModeling,
		    DeiTModel,
		)
		from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import DeiTImageProcessor




class 			_snake_case		:




			def __init__( self    ,							a__    ,							a__=13    ,							a__=30    ,							a__=2    ,							a__=3    ,							a__=True    ,							a__=True    ,							a__=32    ,							a__=5    ,							a__=4    ,							a__=37    ,							a__="gelu"    ,							a__=0.1    ,							a__=0.1    ,							a__=10    ,							a__=0.0_2    ,							a__=3    ,							a__=None    ,							a__=2    ,							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				parent
										snake_case_      =				batch_size
										snake_case_      =				image_size
										snake_case_      =				patch_size
										snake_case_      =				num_channels
										snake_case_      =				is_training
										snake_case_      =				use_labels
										snake_case_      =				hidden_size
										snake_case_      =				num_hidden_layers
										snake_case_      =				num_attention_heads
										snake_case_      =				intermediate_size
										snake_case_      =				hidden_act
										snake_case_      =				hidden_dropout_prob
										snake_case_      =				attention_probs_dropout_prob
										snake_case_      =				type_sequence_label_size
										snake_case_      =				initializer_range
										snake_case_      =				scope
										snake_case_      =				encoder_stride

										# in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
										snake_case_      =				(image_size // patch_size) ** 2
										snake_case_      =				num_patches + 2




			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

										snake_case_      =				None
										if self.use_labels:
																	snake_case_      =				ids_tensor([self.batch_size]    ,							self.type_sequence_label_size							)

										snake_case_      =				self.get_config()

										return config, pixel_values, labels




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										return DeiTConfig(
										    image_size=self.image_size    ,							patch_size=self.patch_size    ,							num_channels=self.num_channels    ,							hidden_size=self.hidden_size    ,							num_hidden_layers=self.num_hidden_layers    ,							num_attention_heads=self.num_attention_heads    ,							intermediate_size=self.intermediate_size    ,							hidden_act=self.hidden_act    ,							hidden_dropout_prob=self.hidden_dropout_prob    ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,							is_decoder=a__    ,							initializer_range=self.initializer_range    ,							encoder_stride=self.encoder_stride    ,							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				DeiTModel(config=a__							)
										model.to(a__							)
										model.eval()
										snake_case_      =				model(a__							)
										self.parent.assertEqual(result.last_hidden_state.shape    ,							(self.batch_size, self.seq_length, self.hidden_size)							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__							)    ->    int:

										'''simple docstring'''




										snake_case_      =				DeiTForMaskedImageModeling(config=a__							)
										model.to(a__							)
										model.eval()
										snake_case_      =				model(a__							)
										self.parent.assertEqual(
										    result.reconstruction.shape    ,							(self.batch_size, self.num_channels, self.image_size, self.image_size)							)

										# test greyscale images
										snake_case_      =				1
										snake_case_      =				DeiTForMaskedImageModeling(a__							)
										model.to(a__							)
										model.eval()

										snake_case_      =				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
										snake_case_      =				model(a__							)
										self.parent.assertEqual(result.reconstruction.shape    ,							(self.batch_size, 1, self.image_size, self.image_size)							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				self.type_sequence_label_size
										snake_case_      =				DeiTForImageClassification(a__							)
										model.to(a__							)
										model.eval()
										snake_case_      =				model(a__    ,							labels=a__							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.type_sequence_label_size)							)

										# test greyscale images
										snake_case_      =				1
										snake_case_      =				DeiTForImageClassification(a__							)
										model.to(a__							)
										model.eval()

										snake_case_      =				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
										snake_case_      =				model(a__    ,							labels=a__							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.type_sequence_label_size)							)




			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										(
										    (
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				
										)      =				config_and_inputs
										snake_case_      =				{"pixel_values": pixel_values}
										return config, inputs_dict




@require_torch
class 			_snake_case		(     lowercase_						,						lowercase_						,						unittest.TestCase							):
			lowerCAmelCase_					:				List[Any]							=   (
			    (
			        DeiTModel,
			        DeiTForImageClassification,
			        DeiTForImageClassificationWithTeacher,
			        DeiTForMaskedImageModeling,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCAmelCase_					:				List[str]							=   (
			    {
			        "feature-extraction": DeiTModel,
			        "image-classification": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
			    }
			    if is_torch_available()
			    else {}
			)

			lowerCAmelCase_					:				Union[str, Any]							=   False
			lowerCAmelCase_					:				List[Any]							=   False
			lowerCAmelCase_					:				int							=   False




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				DeiTModelTester(self							)
										snake_case_      =				ConfigTester(self    ,							config_class=a__    ,							has_text_modality=a__    ,							hidden_size=37							)




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

										'''simple docstring'''




										self.config_tester.run_common_tests()




			@unittest.skip(reason="DeiT does not use inputs_embeds"							)
			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										pass




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

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																	snake_case_      =				model_class(a__							)
																	self.assertIsInstance(model.get_input_embeddings()    ,							(nn.Module)							)
																	snake_case_      =				model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(a__    ,							nn.Linear							)							)




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																	snake_case_      =				model_class(a__							)
																	snake_case_      =				inspect.signature(model.forward							)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	snake_case_      =				[*signature.parameters.keys()]

																	snake_case_      =				["pixel_values"]
																	self.assertListEqual(arg_names[:1]    ,							a__							)




			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*a__							)




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

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*a__							)




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

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*a__							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__=False							)    ->    str:

										'''simple docstring'''




										snake_case_      =				super()._prepare_for_class(a__    ,							a__    ,							return_labels=a__							)

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

										return inputs_dict




			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										if not self.model_tester.is_training:
																	return

										snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()
										snake_case_      =				True

										for model_class in self.all_model_classes:
																	# DeiTForImageClassificationWithTeacher supports inference-only
																	if (
																	    model_class in get_values(a__							)
																	    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
																	):
																								continue
																	snake_case_      =				model_class(a__							)
																	model.to(a__							)
																	model.train()
																	snake_case_      =				self._prepare_for_class(a__    ,							a__    ,							return_labels=a__							)
																	snake_case_      =				model(**a__							).loss
																	loss.backward()




			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()
										if not self.model_tester.is_training:
																	return

										snake_case_      =				False
										snake_case_      =				True

										for model_class in self.all_model_classes:
																	if model_class in get_values(a__							) or not model_class.supports_gradient_checkpointing:
																								continue
																	# DeiTForImageClassificationWithTeacher supports inference-only
																	if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																								continue
																	snake_case_      =				model_class(a__							)
																	model.gradient_checkpointing_enable()
																	model.to(a__							)
																	model.train()
																	snake_case_      =				self._prepare_for_class(a__    ,							a__    ,							return_labels=a__							)
																	snake_case_      =				model(**a__							).loss
																	loss.backward()




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.model_tester.prepare_config_and_inputs_for_common()

										snake_case_      =				[
										    {"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(a__							),
																	        *get_values(a__							),
																	    ]
																	    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
																	):
																								continue

																	for problem_type in problem_types:
																								with self.subTest(msg=F'Testing {model_class} with {problem_type["title"]}'							):
																															snake_case_      =				problem_type["title"]
																															snake_case_      =				problem_type["num_labels"]

																															snake_case_      =				model_class(a__							)
																															model.to(a__							)
																															model.train()

																															snake_case_      =				self._prepare_for_class(a__    ,							a__    ,							return_labels=a__							)

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

																															snake_case_      =				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=a__							) as warning_list:
																																						snake_case_      =				model(**a__							).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							)    ->    Optional[int]:

										'''simple docstring'''




										for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_      =				DeiTModel.from_pretrained(a__							)
																	self.assertIsNotNone(a__							)


def 					UpperCamelCase_(     ):

							'''simple docstring'''






							snake_case_      =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
							return image




@require_torch
@require_vision
class 			_snake_case		(     unittest.TestCase							):




			@cached_property
			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										return (
										    DeiTImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224"							)
										    if is_vision_available()
										    else None
										)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										snake_case_      =				DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224"							).to(
										    a__							)

										snake_case_      =				self.default_image_processor
										snake_case_      =				prepare_img()
										snake_case_      =				image_processor(images=a__    ,							return_tensors="pt"							).to(a__							)

										# forward pass
										with torch.no_grad():
																	snake_case_      =				model(**a__							)

										# verify the logits
										snake_case_      =				torch.Size((1, 1_000)							)
										self.assertEqual(outputs.logits.shape    ,							a__							)

										snake_case_      =				torch.tensor([-1.0_2_6_6, 0.1_9_1_2, -1.2_8_6_1]							).to(a__							)

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




			@slow
			@require_accelerate
			@require_torch_gpu
			def        lowerCAmelCase__    ( self							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				DeiTModel.from_pretrained(
										    "facebook/deit-base-distilled-patch16-224"    ,							torch_dtype=torch.floataa    ,							device_map="auto"							)
										snake_case_      =				self.default_image_processor

										snake_case_      =				prepare_img()
										snake_case_      =				image_processor(images=a__    ,							return_tensors="pt"							)
										snake_case_      =				inputs.pixel_values.to(a__							)

										# forward pass to make sure inference works in fp16
										with torch.no_grad():
																	snake_case_      =				model(a__							)










'''simple docstring'''





from ..utils import DummyObject, requires_backends




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Dict							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    str:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Dict							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Optional[Any]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    str:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[int]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Optional[Any]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				List[str]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[int]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				int							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Any:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Optional[Any]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Any:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    int:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Dict							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[int]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				List[str]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				int							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    int:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Any							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Tuple:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    str:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				str							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Tuple							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    int:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




