


"""simple docstring"""


import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import (
	    TFEfficientFormerForImageClassification,
	    TFEfficientFormerForImageClassificationWithTeacher,
	    TFEfficientFormerModel,
	)
	from transformers.models.efficientformer.modeling_tf_efficientformer import (
	    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
	)


if is_vision_available():
	from PIL import Image

	from transformers import EfficientFormerImageProcessor
class     _UpperCamelCase    :
							'''simple docstring'''







							def __init__(	self       ,  __a       ,  __a = 13       ,  __a = 64       ,  __a = 2       ,  __a = 3       ,  __a = 3       ,  __a = True       ,  __a = True       ,  __a = 1_28       ,  __a=[16, 32, 64, 1_28]       ,  __a = 7       ,  __a = 4       ,  __a = 37       ,  __a = "gelu"       ,  __a = 0.1       ,  __a = 0.1       ,  __a = 10       ,  __a = 0.0_2       ,  __a = 2       ,  __a = 1       ,  __a = 1_28       ,  __a = [2, 2, 2, 2]       ,  __a = 2       ,  __a = 2       ,  ):
										__lowerCAmelCase							       =     parent
										__lowerCAmelCase							       =     batch_size
										__lowerCAmelCase							       =     image_size
										__lowerCAmelCase							       =     patch_size
										__lowerCAmelCase							       =     num_channels
										__lowerCAmelCase							       =     is_training
										__lowerCAmelCase							       =     use_labels
										__lowerCAmelCase							       =     hidden_size
										__lowerCAmelCase							       =     num_hidden_layers
										__lowerCAmelCase							       =     num_attention_heads
										__lowerCAmelCase							       =     intermediate_size
										__lowerCAmelCase							       =     hidden_act
										__lowerCAmelCase							       =     hidden_dropout_prob
										__lowerCAmelCase							       =     attention_probs_dropout_prob
										__lowerCAmelCase							       =     type_sequence_label_size
										__lowerCAmelCase							       =     initializer_range
										__lowerCAmelCase							       =     encoder_stride
										__lowerCAmelCase							       =     num_attention_outputs
										__lowerCAmelCase							       =     embed_dim
										__lowerCAmelCase							       =     embed_dim + 1
										__lowerCAmelCase							       =     resolution
										__lowerCAmelCase							       =     depths
										__lowerCAmelCase							       =     hidden_sizes
										__lowerCAmelCase							       =     dim
										__lowerCAmelCase							       =     mlp_expansion_ratio

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

										__lowerCAmelCase							       =     self.get_config()

										return config, pixel_values, labels

							def      snake_case							(	self      ):
										return EfficientFormerConfig(
										    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       ,  resolution=self.resolution       ,  depths=self.depths       ,  hidden_sizes=self.hidden_sizes       ,  dim=self.dim       ,  mlp_expansion_ratio=self.mlp_expansion_ratio       ,  )

							def      snake_case							(	self       ,  __a       ,  __a       ,  __a      ):
										__lowerCAmelCase							       =     TFEfficientFormerModel(config=__a      )
										__lowerCAmelCase							       =     model(__a       ,  training=__a      )
										self.parent.assertEqual(result.last_hidden_state.shape       ,  (self.batch_size, self.seq_length, self.hidden_size)      )

							def      snake_case							(	self       ,  __a       ,  __a       ,  __a      ):
										__lowerCAmelCase							       =     self.type_sequence_label_size
										__lowerCAmelCase							       =     TFEfficientFormerForImageClassification(__a      )
										__lowerCAmelCase							       =     model(__a       ,  labels=__a       ,  training=__a      )
										self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.type_sequence_label_size)      )

										# test greyscale images
										__lowerCAmelCase							       =     1
										__lowerCAmelCase							       =     TFEfficientFormerForImageClassification(__a      )

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



							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.prepare_config_and_inputs()
										__lowerCAmelCase       ,      __lowerCAmelCase       ,      __lowerCAmelCase							       =     config_and_inputs
										__lowerCAmelCase							       =     {"pixel_values": pixel_values}
										return config, inputs_dict
@require_tf
class     _UpperCamelCase    (  lowerCAmelCase__			,lowerCAmelCase__			,unittest.TestCase						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =(
							    (
							        TFEfficientFormerModel,
							        TFEfficientFormerForImageClassificationWithTeacher,
							        TFEfficientFormerForImageClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							__UpperCAmelCase		:       str							 =(
							    {
							        """feature-extraction""": TFEfficientFormerModel,
							        """image-classification""": (
							            TFEfficientFormerForImageClassification,
							            TFEfficientFormerForImageClassificationWithTeacher,
							        ),
							    }
							    if is_tf_available()
							    else {}
							)

							__UpperCAmelCase		:       str							 =False

							__UpperCAmelCase		:       Optional[Any]							 =False
							__UpperCAmelCase		:       List[str]							 =False
							__UpperCAmelCase		:       List[Any]							 =False
							__UpperCAmelCase		:       Optional[Any]							 =False

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     TFEfficientFormerModelTester(self      )
										__lowerCAmelCase							       =     ConfigTester(
										    self       ,  config_class=__a       ,  has_text_modality=__a       ,  hidden_size=37      )

							def      snake_case							(	self      ):
										self.config_tester.run_common_tests()

							@unittest.skip(reason="EfficientFormer does not use inputs_embeds"      )
							def      snake_case							(	self      ):
										pass

							@unittest.skip(reason="EfficientFormer does not support input and output embeddings"      )
							def      snake_case							(	self      ):
										pass

							def      snake_case							(	self      ):
										__lowerCAmelCase       ,      __lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs_for_common()

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

													__lowerCAmelCase							       =     ["pixel_values"]
													self.assertListEqual(arg_names[:1]       ,  __a      )

							def      snake_case							(	self      ):
										def check_hidden_states_output(__a       ,  __a       ,  __a      ):
													__lowerCAmelCase							       =     model_class(__a      )

													__lowerCAmelCase							       =     model(**self._prepare_for_class(__a       ,  __a      )       ,  training=__a      )
													__lowerCAmelCase							       =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__lowerCAmelCase							       =     getattr(
													    self.model_tester       ,  "expected_num_hidden_layers"       ,  self.model_tester.num_hidden_layers + 1      )
													self.assertEqual(len(__a      )       ,  __a      )

													if hasattr(self.model_tester       ,  "encoder_seq_length"      ):
																__lowerCAmelCase							       =     self.model_tester.encoder_seq_length
																if hasattr(self.model_tester       ,  "chunk_length"      ) and self.model_tester.chunk_length > 1:
																			__lowerCAmelCase							       =     seq_length * self.model_tester.chunk_length
													else:
																__lowerCAmelCase							       =     self.model_tester.seq_length

													self.assertListEqual(
													    list(hidden_states[-1].shape[-2:]      )       ,  [seq_length, self.model_tester.hidden_size]       ,  )

													if config.is_encoder_decoder:
																__lowerCAmelCase							       =     outputs.decoder_hidden_states

																self.asseretIsInstance(__a       ,  (list, tuple)      )
																self.assertEqual(len(__a      )       ,  __a      )
																__lowerCAmelCase							       =     getattr(self.model_tester       ,  "seq_length"       ,  __a      )
																__lowerCAmelCase							       =     getattr(self.model_tester       ,  "decoder_seq_length"       ,  __a      )

																self.assertListEqual(
																    list(hidden_states[-1].shape[-2:]      )       ,  [decoder_seq_length, self.model_tester.hidden_size]       ,  )

										__lowerCAmelCase       ,      __lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													__lowerCAmelCase							       =     True
													check_hidden_states_output(__a       ,  __a       ,  __a      )

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													__lowerCAmelCase							       =     True

													check_hidden_states_output(__a       ,  __a       ,  __a      )

							def      snake_case							(	self       ,  __a       ,  __a       ,  __a=False      ):
										__lowerCAmelCase							       =     super()._prepare_for_class(__a       ,  __a       ,  return_labels=__a      )

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

										return inputs_dict

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__a      )

							@unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"      )
							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*__a      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*__a      )

							@slow
							def      snake_case							(	self      ):
										for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowerCAmelCase							       =     TFEfficientFormerModel.from_pretrained(__a      )
													self.assertIsNotNone(__a      )

							def      snake_case							(	self      ):
										__lowerCAmelCase       ,      __lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs_for_common()
										__lowerCAmelCase							       =     True

										__lowerCAmelCase							       =     getattr(self.model_tester       ,  "seq_length"       ,  __a      )
										__lowerCAmelCase							       =     getattr(self.model_tester       ,  "encoder_seq_length"       ,  __a      )
										__lowerCAmelCase							       =     getattr(self.model_tester       ,  "key_length"       ,  __a      )
										__lowerCAmelCase							       =     getattr(self.model_tester       ,  "chunk_length"       ,  __a      )

										if chunk_length is not None and hasattr(self.model_tester       ,  "num_hashes"      ):
													__lowerCAmelCase							       =     encoder_seq_length * self.model_tester.num_hashes

										for model_class in self.all_model_classes:
													__lowerCAmelCase							       =     True
													__lowerCAmelCase							       =     False
													__lowerCAmelCase							       =     True
													__lowerCAmelCase							       =     model_class(__a      )

													__lowerCAmelCase							       =     model(**self._prepare_for_class(__a       ,  __a      )       ,  training=__a      )
													__lowerCAmelCase							       =     outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
													self.assertEqual(len(__a      )       ,  self.model_tester.num_attention_outputs      )

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													__lowerCAmelCase							       =     True
													__lowerCAmelCase							       =     model_class(__a      )
													__lowerCAmelCase							       =     model(**self._prepare_for_class(__a       ,  __a      )       ,  training=__a      )

													__lowerCAmelCase							       =     outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
													self.assertEqual(len(__a      )       ,  self.model_tester.num_attention_outputs      )

													if chunk_length is not None:
																self.assertListEqual(
																    list(attentions[0].shape[-4:]      )       ,  [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]       ,  )
													else:
																self.assertListEqual(
																    list(attentions[0].shape[-3:]      )       ,  [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]       ,  )



							def      snake_case							(	self      ):
										# We use a simplified version of this test for EfficientFormer because it requires training=False
										# and Keras refuses to let us force that during functional construction
										__lowerCAmelCase       ,      __lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													# Prepare our model
													__lowerCAmelCase							       =     model_class(__a      )
													# These are maximally general inputs for the model, with multiple None dimensions
													# Hopefully this will catch any conditionals that fail for flexible shapes
													__lowerCAmelCase							       =     {
													    key: tf.keras.Input(shape=val.shape[1:]       ,  dtype=val.dtype       ,  name=__a      )
													    for key, val in model.input_signature.items()
													    if key in model.dummy_inputs
													}
													__lowerCAmelCase							       =     model(__a      )
													self.assertTrue(outputs_dict is not None      )


def _lowerCamelCase      (						):

			'''simple docstring'''




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


@require_tf
@require_vision
class     _UpperCamelCase    (  unittest.TestCase						):
							'''simple docstring'''







							@cached_property
							def      snake_case							(	self      ):
										return (
										    EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"      )
										    if is_vision_available()
										    else None
										)

							@slow
							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"      )
										__lowerCAmelCase							       =     self.default_image_processor
										__lowerCAmelCase							       =     prepare_img()
										__lowerCAmelCase							       =     image_processor(images=__a       ,  return_tensors="tf"      )
										# forward pass
										__lowerCAmelCase							       =     model(**__a       ,  training=__a      )
										# verify the logits
										__lowerCAmelCase							       =     tf.TensorShape((1, 10_00)      )
										self.assertEqual(outputs.logits.shape       ,  __a      )
										__lowerCAmelCase							       =     tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]      )
										self.assertTrue(np.allclose(outputs.logits[0, :3]       ,  __a       ,  atol=1e-4      )      )



							@slow
							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
										    "snap-research/efficientformer-l1-300"      )
										__lowerCAmelCase							       =     self.default_image_processor
										__lowerCAmelCase							       =     prepare_img()
										__lowerCAmelCase							       =     image_processor(images=__a       ,  return_tensors="tf"      )
										# forward pass
										__lowerCAmelCase							       =     model(**__a       ,  training=__a      )
										# verify the logits
										__lowerCAmelCase							       =     tf.TensorShape((1, 10_00)      )
										self.assertEqual(outputs.logits.shape       ,  __a      )
										__lowerCAmelCase							       =     tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]      )
										self.assertTrue(np.allclose(outputs.logits[0, :3]       ,  __a       ,  atol=1e-4      )      )








"""simple docstring"""


from ..utils import DummyObject, requires_backends
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )




