"""simple docstring"""






import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch
       from torch import nn

       from transformers import (
           MODEL_MAPPING,
           BeitForImageClassification,
           BeitForMaskedImageModeling,
           BeitForSemanticSegmentation,
           BeitModel,
       )
       from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       import PIL
       from PIL import Image

       from transformers import BeitImageProcessor





class  _A						:

      def __init__(						self		,       __lowerCAmelCase		,       __lowerCAmelCase=100		,       __lowerCAmelCase=13		,       __lowerCAmelCase=30		,       __lowerCAmelCase=2		,       __lowerCAmelCase=3		,       __lowerCAmelCase=True		,       __lowerCAmelCase=True		,       __lowerCAmelCase=32		,       __lowerCAmelCase=4		,       __lowerCAmelCase=4		,       __lowerCAmelCase=37		,       __lowerCAmelCase="gelu"		,       __lowerCAmelCase=0.1		,       __lowerCAmelCase=0.1		,       __lowerCAmelCase=10		,       __lowerCAmelCase=0.0_2		,       __lowerCAmelCase=3		,       __lowerCAmelCase=None		,       __lowerCAmelCase=[0, 1, 2, 3]		,       ):







            """simple docstring"""



            lowercase														=	parent
            lowercase														=	100
            lowercase														=	batch_size
            lowercase														=	image_size
            lowercase														=	patch_size
            lowercase														=	num_channels
            lowercase														=	is_training
            lowercase														=	use_labels
            lowercase														=	hidden_size
            lowercase														=	num_hidden_layers
            lowercase														=	num_attention_heads
            lowercase														=	intermediate_size
            lowercase														=	hidden_act
            lowercase														=	hidden_dropout_prob
            lowercase														=	attention_probs_dropout_prob
            lowercase														=	type_sequence_label_size
            lowercase														=	initializer_range
            lowercase														=	scope
            lowercase														=	out_indices
            lowercase														=	num_labels

            # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
            lowercase														=	(image_size // patch_size) ** 2
            lowercase														=	num_patches + 1

      def 				A__       (						self						):







            """simple docstring"""



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

            lowercase														=	None
            lowercase														=	None
            if self.use_labels:
                  lowercase														=	ids_tensor([self.batch_size]		,       self.type_sequence_label_size						)
                  lowercase														=	ids_tensor([self.batch_size, self.image_size, self.image_size]		,       self.num_labels						)

            lowercase														=	self.get_config()

            return config, pixel_values, labels, pixel_labels

      def 				A__       (						self						):







            """simple docstring"""



            return BeitConfig(
                vocab_size=self.vocab_size		,       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=__lowerCAmelCase		,       initializer_range=self.initializer_range		,       out_indices=self.out_indices		,       )

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	BeitModel(config=__lowerCAmelCase						)
            model.to(__lowerCAmelCase						)
            model.eval()
            lowercase														=	model(__lowerCAmelCase						)
            self.parent.assertEqual(result.last_hidden_state.shape		,       (self.batch_size, self.seq_length, self.hidden_size)						)

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	BeitForMaskedImageModeling(config=__lowerCAmelCase						)
            model.to(__lowerCAmelCase						)
            model.eval()
            lowercase														=	model(__lowerCAmelCase						)
            self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.seq_length - 1, self.vocab_size)						)

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	self.type_sequence_label_size
            lowercase														=	BeitForImageClassification(__lowerCAmelCase						)
            model.to(__lowerCAmelCase						)
            model.eval()
            lowercase														=	model(__lowerCAmelCase		,       labels=__lowerCAmelCase						)
            self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.type_sequence_label_size)						)

            # test greyscale images
            lowercase														=	1
            lowercase														=	BeitForImageClassification(__lowerCAmelCase						)
            model.to(__lowerCAmelCase						)
            model.eval()

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

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	self.num_labels
            lowercase														=	BeitForSemanticSegmentation(__lowerCAmelCase						)
            model.to(__lowerCAmelCase						)
            model.eval()
            lowercase														=	model(__lowerCAmelCase						)
            self.parent.assertEqual(
                result.logits.shape		,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)						)
            lowercase														=	model(__lowerCAmelCase		,       labels=__lowerCAmelCase						)
            self.parent.assertEqual(
                result.logits.shape		,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)						)







      def 				A__       (						self						):







            """simple docstring"""



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






@require_torch
class  _A						(       lowerCAmelCase  ,    lowerCAmelCase  ,    unittest.TestCase	):
      snake_case__			:   str							  =	(
          (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
          if is_torch_available()
          else ()
      )
      snake_case__			:   Any							  =	(
          {
              'feature-extraction': BeitModel,
              'image-classification': BeitForImageClassification,
              'image-segmentation': BeitForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      snake_case__			:   Any							  =	False
      snake_case__			:   Dict							  =	False
      snake_case__			:   Optional[Any]							  =	False

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	BeitModelTester(self						)
            lowercase														=	ConfigTester(self		,       config_class=__lowerCAmelCase		,       has_text_modality=__lowerCAmelCase		,       hidden_size=37						)

      def 				A__       (						self						):







            """simple docstring"""



            self.config_tester.run_common_tests()

      @unittest.skip(reason="""BEiT does not use inputs_embeds"""						)
      def 				A__       (						self						):







            """simple docstring"""



            pass

      @require_torch_multi_gpu
      @unittest.skip(reason="""BEiT has some layers using `add_module` which doesn't work well with `nn.DataParallel`"""						)
      def 				A__       (						self						):







            """simple docstring"""



            pass

      def 				A__       (						self						):







            """simple docstring"""



            lowercase							,							lowercase														=	self.model_tester.prepare_config_and_inputs_for_common()

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

      def 				A__       (						self						):







            """simple docstring"""



            lowercase							,							lowercase														=	self.model_tester.prepare_config_and_inputs_for_common()

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

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

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_semantic_segmentation(*__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            if not self.model_tester.is_training:
                  return

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

            for model_class in self.all_model_classes:
                  # we don't test BeitForMaskedImageModeling
                  if model_class in [*get_values(__lowerCAmelCase						), BeitForMaskedImageModeling]:
                        continue

                  lowercase														=	model_class(__lowerCAmelCase						)
                  model.to(__lowerCAmelCase						)
                  model.train()
                  lowercase														=	self._prepare_for_class(__lowerCAmelCase		,       __lowerCAmelCase		,       return_labels=__lowerCAmelCase						)
                  lowercase														=	model(**__lowerCAmelCase						).loss
                  loss.backward()

      def 				A__       (						self						):







            """simple docstring"""



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

            lowercase														=	False
            lowercase														=	True

            for model_class in self.all_model_classes:
                  # we don't test BeitForMaskedImageModeling
                  if (
                      model_class in [*get_values(__lowerCAmelCase						), BeitForMaskedImageModeling]
                      or not model_class.supports_gradient_checkpointing
                  ):
                        continue

                  lowercase														=	model_class(__lowerCAmelCase						)
                  model.gradient_checkpointing_enable()
                  model.to(__lowerCAmelCase						)
                  model.train()
                  lowercase														=	self._prepare_for_class(__lowerCAmelCase		,       __lowerCAmelCase		,       return_labels=__lowerCAmelCase						)
                  lowercase														=	model(**__lowerCAmelCase						).loss
                  loss.backward()

      def 				A__       (						self						):







            """simple docstring"""



            lowercase							,							lowercase														=	self.model_tester.prepare_config_and_inputs_for_common()

            lowercase														=	_config_zero_init(__lowerCAmelCase						)
            for model_class in self.all_model_classes:
                  lowercase														=	model_class(config=__lowerCAmelCase						)
                  for name, param in model.named_parameters():
                        # we skip lambda parameters as these require special initial values
                        # determined by config.layer_scale_init_value
                        if "lambda" in name:
                              continue
                        if param.requires_grad:
                              self.assertIn(
                                  ((param.data.mean() * 1E9).round() / 1E9).item()		,       [0.0, 1.0]		,       msg=f'Parameter {name} of model {model_class} seems not properly initialized'		,       )







      @slow
      def 				A__       (						self						):







            """simple docstring"""



            for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowercase														=	BeitModel.from_pretrained(__lowerCAmelCase						)
                  self.assertIsNotNone(__lowerCAmelCase						)






def 			UpperCAmelCase__       (				) ->    List[Any]:
      '''simple docstring'''


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






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

      @cached_property
      def 				A__       (						self						):







            """simple docstring"""



            return BeitImageProcessor.from_pretrained("""microsoft/beit-base-patch16-224"""						) if is_vision_available() else None

      @slow
      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	BeitForMaskedImageModeling.from_pretrained("""microsoft/beit-base-patch16-224-pt22k"""						).to(__lowerCAmelCase						)

            lowercase														=	self.default_image_processor
            lowercase														=	prepare_img()
            lowercase														=	image_processor(images=__lowerCAmelCase		,       return_tensors="""pt"""						).pixel_values.to(__lowerCAmelCase						)

            # prepare bool_masked_pos
            lowercase														=	torch.ones((1, 196)		,       dtype=torch.bool						).to(__lowerCAmelCase						)

            # forward pass
            with torch.no_grad():
                  lowercase														=	model(pixel_values=__lowerCAmelCase		,       bool_masked_pos=__lowerCAmelCase						)
            lowercase														=	outputs.logits

            # verify the logits
            lowercase														=	torch.Size((1, 196, 8192)						)
            self.assertEqual(logits.shape		,       __lowerCAmelCase						)

            lowercase														=	torch.tensor(
                [[-3.2_4_3_7, 0.5_0_7_2, -1_3.9_1_7_4], [-3.2_4_5_6, 0.4_9_4_8, -1_3.9_4_0_1], [-3.2_0_3_3, 0.5_1_2_1, -1_3.8_5_5_0]]						).to(__lowerCAmelCase						)

            self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]		,       __lowerCAmelCase		,       atol=1E-2						)						)

      @slow
      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	BeitForImageClassification.from_pretrained("""microsoft/beit-base-patch16-224"""						).to(__lowerCAmelCase						)

            lowercase														=	self.default_image_processor
            lowercase														=	prepare_img()
            lowercase														=	image_processor(images=__lowerCAmelCase		,       return_tensors="""pt"""						).to(__lowerCAmelCase						)

            # forward pass
            with torch.no_grad():
                  lowercase														=	model(**__lowerCAmelCase						)
            lowercase														=	outputs.logits

            # verify the logits
            lowercase														=	torch.Size((1, 1000)						)
            self.assertEqual(logits.shape		,       __lowerCAmelCase						)

            lowercase														=	torch.tensor([-1.2_3_8_5, -1.0_9_8_7, -1.0_1_0_8]						).to(__lowerCAmelCase						)

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

            lowercase														=	281
            self.assertEqual(logits.argmax(-1						).item()		,       __lowerCAmelCase						)

      @slow
      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	BeitForImageClassification.from_pretrained("""microsoft/beit-large-patch16-224-pt22k-ft22k"""						).to(
                __lowerCAmelCase						)

            lowercase														=	self.default_image_processor
            lowercase														=	prepare_img()
            lowercase														=	image_processor(images=__lowerCAmelCase		,       return_tensors="""pt"""						).to(__lowerCAmelCase						)

            # forward pass
            with torch.no_grad():
                  lowercase														=	model(**__lowerCAmelCase						)
            lowercase														=	outputs.logits

            # verify the logits
            lowercase														=	torch.Size((1, 2_1841)						)
            self.assertEqual(logits.shape		,       __lowerCAmelCase						)

            lowercase														=	torch.tensor([1.6_8_8_1, -0.2_7_8_7, 0.5_9_0_1]						).to(__lowerCAmelCase						)

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

            lowercase														=	2396
            self.assertEqual(logits.argmax(-1						).item()		,       __lowerCAmelCase						)

      @slow
      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	BeitForSemanticSegmentation.from_pretrained("""microsoft/beit-base-finetuned-ade-640-640"""						)
            lowercase														=	model.to(__lowerCAmelCase						)

            lowercase														=	BeitImageProcessor(do_resize=__lowerCAmelCase		,       size=640		,       do_center_crop=__lowerCAmelCase						)

            lowercase														=	load_dataset("""hf-internal-testing/fixtures_ade20k"""		,       split="""test"""						)
            lowercase														=	Image.open(ds[0]["""file"""]						)
            lowercase														=	image_processor(images=__lowerCAmelCase		,       return_tensors="""pt"""						).to(__lowerCAmelCase						)

            # forward pass
            with torch.no_grad():
                  lowercase														=	model(**__lowerCAmelCase						)
            lowercase														=	outputs.logits

            # verify the logits
            lowercase														=	torch.Size((1, 150, 160, 160)						)
            self.assertEqual(logits.shape		,       __lowerCAmelCase						)

            lowercase														=	version.parse(PIL.__version__						) < version.parse("""9.0.0"""						)

            if is_pillow_less_than_a:
                  lowercase														=	torch.tensor(
                      [
                          [[-4.9_2_2_5, -2.3_9_5_4, -3.0_5_2_2], [-2.8_8_2_2, -1.0_0_4_6, -1.7_5_6_1], [-2.9_5_4_9, -1.3_2_2_8, -2.1_3_4_7]],
                          [[-5.8_1_6_8, -3.4_1_2_9, -4.0_7_7_8], [-3.8_6_5_1, -2.2_2_1_4, -3.0_2_7_7], [-3.8_3_5_6, -2.4_6_4_3, -3.3_5_3_5]],
                          [[-0.0_0_7_8, 3.9_9_5_2, 4.0_7_5_4], [2.9_8_5_6, 4.6_9_4_4, 5.0_0_3_5], [3.2_4_1_3, 4.7_8_1_3, 4.9_9_6_9]],
                      ]		,       device=__lowerCAmelCase		,       )
            else:
                  lowercase														=	torch.tensor(
                      [
                          [[-4.8_9_6_0, -2.3_6_8_8, -3.0_3_5_5], [-2.8_4_7_8, -0.9_8_3_6, -1.7_4_1_8], [-2.9_4_4_9, -1.3_3_3_2, -2.1_4_5_6]],
                          [[-5.8_0_8_1, -3.4_1_2_4, -4.1_0_0_6], [-3.8_5_6_1, -2.2_0_8_1, -3.0_3_2_3], [-3.8_3_6_5, -2.4_6_0_1, -3.3_6_6_9]],
                          [[-0.0_3_0_9, 3.9_8_6_8, 4.0_5_4_0], [2.9_6_4_0, 4.6_8_7_7, 4.9_9_7_6], [3.2_0_8_1, 4.7_6_9_0, 4.9_9_4_2]],
                      ]		,       device=__lowerCAmelCase		,       )

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







      @slow
      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	BeitForSemanticSegmentation.from_pretrained("""microsoft/beit-base-finetuned-ade-640-640"""						)
            lowercase														=	model.to(__lowerCAmelCase						)

            lowercase														=	BeitImageProcessor(do_resize=__lowerCAmelCase		,       size=640		,       do_center_crop=__lowerCAmelCase						)

            lowercase														=	load_dataset("""hf-internal-testing/fixtures_ade20k"""		,       split="""test"""						)
            lowercase														=	Image.open(ds[0]["""file"""]						)
            lowercase														=	image_processor(images=__lowerCAmelCase		,       return_tensors="""pt"""						).to(__lowerCAmelCase						)

            # forward pass
            with torch.no_grad():
                  lowercase														=	model(**__lowerCAmelCase						)

            lowercase														=	outputs.logits.detach().cpu()

            lowercase														=	image_processor.post_process_semantic_segmentation(outputs=__lowerCAmelCase		,       target_sizes=[(500, 300)]						)
            lowercase														=	torch.Size((500, 300)						)
            self.assertEqual(segmentation[0].shape		,       __lowerCAmelCase						)

            lowercase														=	image_processor.post_process_semantic_segmentation(outputs=__lowerCAmelCase						)
            lowercase														=	torch.Size((160, 160)						)
            self.assertEqual(segmentation[0].shape		,       __lowerCAmelCase						)




"""simple docstring"""






from ..utils import DummyObject, requires_backends





class  _A						(       metaclass=lowerCAmelCase	):
      snake_case__			:   str							  =	['torch', 'transformers', 'onnx']

      def __init__(						self		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(self		,       ["""torch""", """transformers""", """onnx"""]						)

      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)







      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)






class  _A						(       metaclass=lowerCAmelCase	):
      snake_case__			:   List[Any]							  =	['torch', 'transformers', 'onnx']

      def __init__(						self		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(self		,       ["""torch""", """transformers""", """onnx"""]						)

      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)







      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)






class  _A						(       metaclass=lowerCAmelCase	):
      snake_case__			:   Optional[Any]							  =	['torch', 'transformers', 'onnx']

      def __init__(						self		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(self		,       ["""torch""", """transformers""", """onnx"""]						)

      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)







      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)






class  _A						(       metaclass=lowerCAmelCase	):
      snake_case__			:   int							  =	['torch', 'transformers', 'onnx']

      def __init__(						self		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(self		,       ["""torch""", """transformers""", """onnx"""]						)

      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)







      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)






class  _A						(       metaclass=lowerCAmelCase	):
      snake_case__			:   List[str]							  =	['torch', 'transformers', 'onnx']

      def __init__(						self		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(self		,       ["""torch""", """transformers""", """onnx"""]						)

      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)







      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)






class  _A						(       metaclass=lowerCAmelCase	):
      snake_case__			:   Optional[Any]							  =	['torch', 'transformers', 'onnx']

      def __init__(						self		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(self		,       ["""torch""", """transformers""", """onnx"""]						)

      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)







      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""torch""", """transformers""", """onnx"""]						)



