



"""simple docstring"""




import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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 transformers import (
					    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
					    MODEL_MAPPING,
					    EfficientFormerForImageClassification,
					    EfficientFormerForImageClassificationWithTeacher,
					    EfficientFormerModel,
					)
					from transformers.models.efficientformer.modeling_efficientformer import (
					    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
					)


if is_vision_available():
					from PIL import Image

					from transformers import EfficientFormerImageProcessor


class   a__		:


			def __init__(							self      :							Dict,     lowerCAmelCase      :							str,     lowerCAmelCase      :							List[str] = 13,     lowerCAmelCase      :							List[str] = 64,     lowerCAmelCase      :							Dict = 2,     lowerCAmelCase      :							Optional[int] = 3,     lowerCAmelCase      :							str = 3,     lowerCAmelCase      :							str = True,     lowerCAmelCase      :							int = True,     lowerCAmelCase      :							List[str] = 128,     lowerCAmelCase      :							Any=[16, 32, 64, 128],     lowerCAmelCase      :							str = 7,     lowerCAmelCase      :							List[str] = 4,     lowerCAmelCase      :							List[str] = 37,     lowerCAmelCase      :							Any = "gelu",     lowerCAmelCase      :							List[str] = 0.1,     lowerCAmelCase      :							Dict = 0.1,     lowerCAmelCase      :							str = 10,     lowerCAmelCase      :							Optional[int] = 0.02,     lowerCAmelCase      :							Optional[Any] = 2,     lowerCAmelCase      :							List[Any] = 1,     lowerCAmelCase      :							str = 128,     lowerCAmelCase      :							List[str] = [2, 2, 2, 2],     lowerCAmelCase      :							Union[str, Any] = 2,     lowerCAmelCase      :							Union[str, Any] = 2,     )    ->       Any:
									lowercase  :      Tuple					=   parent
									lowercase  :      Optional[int]					=   batch_size
									lowercase  :      Union[str, Any]					=   image_size
									lowercase  :      int					=   patch_size
									lowercase  :      Tuple					=   num_channels
									lowercase  :      Tuple					=   is_training
									lowercase  :      Tuple					=   use_labels
									lowercase  :      str					=   hidden_size
									lowercase  :      Tuple					=   num_hidden_layers
									lowercase  :      List[str]					=   num_attention_heads
									lowercase  :      Dict					=   intermediate_size
									lowercase  :      Any					=   hidden_act
									lowercase  :      List[str]					=   hidden_dropout_prob
									lowercase  :      List[str]					=   attention_probs_dropout_prob
									lowercase  :      str					=   type_sequence_label_size
									lowercase  :      Any					=   initializer_range
									lowercase  :      Any					=   encoder_stride
									lowercase  :      Union[str, Any]					=   num_attention_outputs
									lowercase  :      List[Any]					=   embed_dim
									lowercase  :      Union[str, Any]					=   embed_dim + 1
									lowercase  :      Optional[int]					=   resolution
									lowercase  :      int					=   depths
									lowercase  :      Union[str, Any]					=   hidden_sizes
									lowercase  :      List[str]					=   dim
									lowercase  :      Any					=   mlp_expansion_ratio


			def        lowercase				(							self      :							List[str]			)    ->       List[str]:
									lowercase  :      str					=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

									lowercase  :      Optional[Any]					=   None
									if self.use_labels:
															lowercase  :      Optional[int]					=   ids_tensor([self.batch_size],     self.type_sequence_label_size			)

									lowercase  :      Any					=   self.get_config()
									return config, pixel_values, labels


			def        lowercase				(							self      :							Tuple			)    ->       Optional[Any]:
									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=lowerCAmelCase,     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        lowercase				(							self      :							List[str],     lowerCAmelCase      :							Union[str, Any],     lowerCAmelCase      :							Tuple,     lowerCAmelCase      :							Dict			)    ->       Dict:
									lowercase  :      int					=   EfficientFormerModel(config=lowerCAmelCase			)
									model.to(lowerCAmelCase			)
									model.eval()
									lowercase  :      Tuple					=   model(lowerCAmelCase			)
									self.parent.assertEqual(result.last_hidden_state.shape,     (self.batch_size, self.seq_length, self.hidden_size)			)


			def        lowercase				(							self      :							Union[str, Any],     lowerCAmelCase      :							int,     lowerCAmelCase      :							List[str],     lowerCAmelCase      :							Dict			)    ->       str:
									lowercase  :      Union[str, Any]					=   self.type_sequence_label_size
									lowercase  :      int					=   EfficientFormerForImageClassification(lowerCAmelCase			)
									model.to(lowerCAmelCase			)
									model.eval()
									lowercase  :      str					=   model(lowerCAmelCase,     labels=lowerCAmelCase			)
									self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.type_sequence_label_size)			)

									# test greyscale images
									lowercase  :      Optional[Any]					=   1
									lowercase  :      Dict					=   EfficientFormerForImageClassification(lowerCAmelCase			)
									model.to(lowerCAmelCase			)
									model.eval()

									lowercase  :      List[str]					=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
									lowercase  :      Optional[int]					=   model(lowerCAmelCase			)
									self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.type_sequence_label_size)			)






			def        lowercase				(							self      :							List[Any]			)    ->       Optional[Any]:
									lowercase  :      Optional[Any]					=   self.prepare_config_and_inputs()
									(
									    (
									    lowercase       
									)	,    (
									    lowercase       
									)	,    (
									    lowercase       
									)	,           
									)  :      Dict					=   config_and_inputs
									lowercase  :      List[Any]					=   {'pixel_values': pixel_values}
									return config, inputs_dict




@require_torch
class   a__		(						_UpperCAmelCase,  _UpperCAmelCase,  unittest.TestCase     ):
			_lowerCamelCase												=				(
			    (
			        EfficientFormerModel,
			        EfficientFormerForImageClassificationWithTeacher,
			        EfficientFormerForImageClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			_lowerCamelCase												=				(
			    {
			        'feature-extraction': EfficientFormerModel,
			        'image-classification': (
			            EfficientFormerForImageClassification,
			            EfficientFormerForImageClassificationWithTeacher,
			        ),
			    }
			    if is_torch_available()
			    else {}
			)
			_lowerCamelCase												=				False

			_lowerCamelCase												=				False
			_lowerCamelCase												=				False
			_lowerCamelCase												=				False


			def        lowercase				(							self      :							Dict			)    ->       Optional[int]:
									lowercase  :      Optional[Any]					=   EfficientFormerModelTester(self			)
									lowercase  :      List[str]					=   ConfigTester(
									    self,     config_class=lowerCAmelCase,     has_text_modality=lowerCAmelCase,     hidden_size=37			)


			def        lowercase				(							self      :							Union[str, Any]			)    ->       List[str]:
									self.config_tester.run_common_tests()


			@unittest.skip(reason='EfficientFormer does not use inputs_embeds'			)
			def        lowercase				(							self      :							List[str]			)    ->       Dict:
									pass


			@unittest.skip(reason='EfficientFormer does not support input and output embeddings'			)
			def        lowercase				(							self      :							Dict			)    ->       str:
									pass


			def        lowercase				(							self      :							Optional[int]			)    ->       Optional[Any]:
									lowercase	,    lowercase  :      str					=   self.model_tester.prepare_config_and_inputs_for_common()

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

															lowercase  :      Optional[Any]					=   ['pixel_values']
															self.assertListEqual(arg_names[:1],     lowerCAmelCase			)


			def        lowercase				(							self      :							Dict			)    ->       Any:






									def check_hidden_states_output(lowerCAmelCase      :							str,     lowerCAmelCase      :							Union[str, Any],     lowerCAmelCase      :							List[Any]			):
															lowercase  :      str					=   model_class(lowerCAmelCase			)
															model.to(lowerCAmelCase			)
															model.eval()

															with torch.no_grad():
																					lowercase  :      Optional[int]					=   model(**self._prepare_for_class(lowerCAmelCase,     lowerCAmelCase			)			)

															lowercase  :      int					=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															lowercase  :      Union[str, Any]					=   getattr(
															    self.model_tester,     'expected_num_hidden_layers',     self.model_tester.num_hidden_layers + 1			)
															self.assertEqual(len(lowerCAmelCase			),     lowerCAmelCase			)

															if hasattr(self.model_tester,     'encoder_seq_length'			):
																					lowercase  :      Union[str, Any]					=   self.model_tester.encoder_seq_length
																					if hasattr(self.model_tester,     'chunk_length'			) and self.model_tester.chunk_length > 1:
																											lowercase  :      Union[str, Any]					=   seq_length * self.model_tester.chunk_length
															else:
																					lowercase  :      int					=   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:
																					lowercase  :      Dict					=   outputs.decoder_hidden_states

																					self.assertIsInstance(lowerCAmelCase,     (list, tuple)			)
																					self.assertEqual(len(lowerCAmelCase			),     lowerCAmelCase			)
																					lowercase  :      List[str]					=   getattr(self.model_tester,     'seq_length',     lowerCAmelCase			)
																					lowercase  :      str					=   getattr(self.model_tester,     'decoder_seq_length',     lowerCAmelCase			)

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

									lowercase	,    lowercase  :      Union[str, Any]					=   self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															lowercase  :      str					=   True
															check_hidden_states_output(lowerCAmelCase,     lowerCAmelCase,     lowerCAmelCase			)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															lowercase  :      Dict					=   True

															check_hidden_states_output(lowerCAmelCase,     lowerCAmelCase,     lowerCAmelCase			)


			def        lowercase				(							self      :							Tuple,     lowerCAmelCase      :							List[str],     lowerCAmelCase      :							Optional[int],     lowerCAmelCase      :							List[str]=False			)    ->       Any:
									lowercase  :      Dict					=   super()._prepare_for_class(lowerCAmelCase,     lowerCAmelCase,     return_labels=lowerCAmelCase			)

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

									return inputs_dict


			def        lowercase				(							self      :							Optional[Any]			)    ->       Optional[int]:
									lowercase  :      Optional[int]					=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowerCAmelCase			)


			@unittest.skip(reason='EfficientFormer does not implement masked image modeling yet'			)
			def        lowercase				(							self      :							Optional[int]			)    ->       Union[str, Any]:
									lowercase  :      List[Any]					=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase			)


			def        lowercase				(							self      :							Tuple			)    ->       Dict:
									lowercase  :      Any					=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase			)


			def        lowercase				(							self      :							Any			)    ->       Tuple:






									if not self.model_tester.is_training:
															return

									lowercase	,    lowercase  :      Union[str, Any]					=   self.model_tester.prepare_config_and_inputs_for_common()
									lowercase  :      Any					=   True

									for model_class in self.all_model_classes:
															# EfficientFormerForImageClassificationWithTeacher supports inference-only
															if (
															    model_class in get_values(lowerCAmelCase			)
															    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
															):
																					continue
															lowercase  :      int					=   model_class(lowerCAmelCase			)
															model.to(lowerCAmelCase			)
															model.train()
															lowercase  :      str					=   self._prepare_for_class(lowerCAmelCase,     lowerCAmelCase,     return_labels=lowerCAmelCase			)
															lowercase  :      Any					=   model(**lowerCAmelCase			).loss
															loss.backward()


			def        lowercase				(							self      :							List[Any]			)    ->       int:
									lowercase	,    lowercase  :      Dict					=   self.model_tester.prepare_config_and_inputs_for_common()

									lowercase  :      List[Any]					=   [
									    {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
									    {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
									    {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
									]

									for model_class in self.all_model_classes:
															if (
															    model_class
															    not in [
															        *get_values(lowerCAmelCase			),
															    ]
															    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
															):
																					continue

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

																											lowercase  :      Any					=   model_class(lowerCAmelCase			)
																											model.to(lowerCAmelCase			)
																											model.train()

																											lowercase  :      Optional[Any]					=   self._prepare_for_class(lowerCAmelCase,     lowerCAmelCase,     return_labels=lowerCAmelCase			)

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

																											lowercase  :      Optional[Any]					=   inputs['labels'].to(problem_type['dtype']			)

																											# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																											# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																											# they have the same size." which is a symptom something in wrong for the regression problem.
																											# See https://github.com/huggingface/transformers/issues/11780
																											with warnings.catch_warnings(record=lowerCAmelCase			) as warning_list:
																																	lowercase  :      List[str]					=   model(**lowerCAmelCase			).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        lowercase				(							self      :							Tuple			)    ->       Union[str, Any]:






									for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowercase  :      Dict					=   EfficientFormerModel.from_pretrained(lowerCAmelCase			)
															self.assertIsNotNone(lowerCAmelCase			)






			def        lowercase				(							self      :							Any			)    ->       Any:
									lowercase	,    lowercase  :      Union[str, Any]					=   self.model_tester.prepare_config_and_inputs_for_common()
									lowercase  :      Optional[int]					=   True

									lowercase  :      List[str]					=   getattr(self.model_tester,     'seq_length',     lowerCAmelCase			)
									lowercase  :      Union[str, Any]					=   getattr(self.model_tester,     'encoder_seq_length',     lowerCAmelCase			)
									lowercase  :      Optional[int]					=   getattr(self.model_tester,     'key_length',     lowerCAmelCase			)
									lowercase  :      int					=   getattr(self.model_tester,     'chunk_length',     lowerCAmelCase			)

									if chunk_length is not None and hasattr(self.model_tester,     'num_hashes'			):
															lowercase  :      Tuple					=   encoder_seq_length * self.model_tester.num_hashes

									for model_class in self.all_model_classes:
															lowercase  :      Optional[Any]					=   True
															lowercase  :      Any					=   False
															lowercase  :      Tuple					=   True
															lowercase  :      List[str]					=   model_class(lowerCAmelCase			)
															model.to(lowerCAmelCase			)
															model.eval()
															with torch.no_grad():
																					lowercase  :      Optional[int]					=   model(**self._prepare_for_class(lowerCAmelCase,     lowerCAmelCase			)			)
															lowercase  :      List[Any]					=   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(lowerCAmelCase			),     self.model_tester.num_attention_outputs			)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															lowercase  :      str					=   True
															lowercase  :      List[Any]					=   model_class(lowerCAmelCase			)
															model.to(lowerCAmelCase			)
															model.eval()
															with torch.no_grad():
																					lowercase  :      Tuple					=   model(**self._prepare_for_class(lowerCAmelCase,     lowerCAmelCase			)			)
															lowercase  :      List[str]					=   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(lowerCAmelCase			),     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   lowercase__     (			)     ->			str:






						'''simple docstring'''


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





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


			@cached_property
			def        lowercase				(							self      :							Optional[Any]			)    ->       List[Any]:
									return (
									    EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300'			)
									    if is_vision_available()
									    else None
									)


			@slow
			def        lowercase				(							self      :							List[str]			)    ->       str:
									lowercase  :      int					=   EfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'			).to(
									    lowerCAmelCase			)

									lowercase  :      Any					=   self.default_image_processor
									lowercase  :      List[Any]					=   prepare_img()
									lowercase  :      Any					=   image_processor(images=lowerCAmelCase,     return_tensors='pt'			).to(lowerCAmelCase			)

									# forward pass
									with torch.no_grad():
															lowercase  :      List[str]					=   model(**lowerCAmelCase			)

									# verify the logits
									lowercase  :      Optional[int]					=   (1, 1000)
									self.assertEqual(outputs.logits.shape,     lowerCAmelCase			)

									lowercase  :      Tuple					=   torch.tensor([-0.0555, 0.4825, -0.0852]			).to(lowerCAmelCase			)
									self.assertTrue(torch.allclose(outputs.logits[0][:3],     lowerCAmelCase,     atol=1e-4			)			)






			@slow
			def        lowercase				(							self      :							int			)    ->       Optional[int]:
									lowercase  :      str					=   EfficientFormerForImageClassificationWithTeacher.from_pretrained(
									    'snap-research/efficientformer-l1-300'			).to(lowerCAmelCase			)

									lowercase  :      Any					=   self.default_image_processor
									lowercase  :      Tuple					=   prepare_img()
									lowercase  :      Union[str, Any]					=   image_processor(images=lowerCAmelCase,     return_tensors='pt'			).to(lowerCAmelCase			)

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

									# verify the logits
									lowercase  :      str					=   (1, 1000)
									self.assertEqual(outputs.logits.shape,     lowerCAmelCase			)

									lowercase  :      Tuple					=   torch.tensor([-0.1312, 0.4353, -1.0499]			).to(lowerCAmelCase			)
									self.assertTrue(torch.allclose(outputs.logits[0][:3],     lowerCAmelCase,     atol=1e-4			)			)





"""simple docstring"""




import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin


class   a__		(						SCREAMING_SNAKE_CASE__     ):
   _lowerCamelCase												=				'AutoFeatureExtractor'
   _lowerCamelCase												=				'Speech2Text2Tokenizer'


   def __init__(							self      :							str,     lowerCAmelCase      :							List[str],     lowerCAmelCase      :							Optional[Any]			)    ->       Dict:
         super().__init__(lowerCAmelCase,     lowerCAmelCase			)
         lowercase  :      Tuple					=   self.feature_extractor
         lowercase  :      Any					=   False


   def __call__(							self      :							Tuple,     *lowerCAmelCase      :							Tuple,     **lowerCAmelCase      :							Tuple			)    ->       Dict:
         # For backward compatibility
         if self._in_target_context_manager:
               return self.current_processor(*lowerCAmelCase,     **lowerCAmelCase			)

         if "raw_speech" in kwargs:
               warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'			)
               lowercase  :      str					=   kwargs.pop('raw_speech'			)
         else:
               lowercase  :      str					=   kwargs.pop('audio',     lowerCAmelCase			)
         lowercase  :      Dict					=   kwargs.pop('sampling_rate',     lowerCAmelCase			)
         lowercase  :      Optional[Any]					=   kwargs.pop('text',     lowerCAmelCase			)
         if len(lowerCAmelCase			) > 0:
               lowercase  :      Any					=   args[0]
               lowercase  :      int					=   args[1:]

         if audio is None and text is None:
               raise ValueError('You need to specify either an `audio` or `text` input to process.'			)

         if audio is not None:
               lowercase  :      List[Any]					=   self.feature_extractor(lowerCAmelCase,     *lowerCAmelCase,     sampling_rate=lowerCAmelCase,     **lowerCAmelCase			)
         if text is not None:
               lowercase  :      str					=   self.tokenizer(lowerCAmelCase,     **lowerCAmelCase			)

         if text is None:
               return inputs
         elif audio is None:
               return encodings
         else:
               lowercase  :      Tuple					=   encodings['input_ids']
               return inputs


   def        lowercase				(							self      :							str,     *lowerCAmelCase      :							List[str],     **lowerCAmelCase      :							Union[str, Any]			)    ->       str:
         return self.tokenizer.batch_decode(*lowerCAmelCase,     **lowerCAmelCase			)


   def        lowercase				(							self      :							Tuple,     *lowerCAmelCase      :							Union[str, Any],     **lowerCAmelCase      :							int			)    ->       Dict:
         return self.tokenizer.decode(*lowerCAmelCase,     **lowerCAmelCase			)






   @contextmanager
   def        lowercase				(							self      :							str			)    ->       Any:
         warnings.warn(
             '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
             'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
             'your audio inputs, or in a separate call.'			)
         lowercase  :      Optional[Any]					=   True
         lowercase  :      Any					=   self.tokenizer
         yield
         lowercase  :      Any					=   self.feature_extractor
         lowercase  :      Any					=   False
