



'''simple docstring'''





import unittest

from transformers import MobileBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       MODEL_FOR_PRETRAINING_MAPPING,
       MobileBertForMaskedLM,
       MobileBertForMultipleChoice,
       MobileBertForNextSentencePrediction,
       MobileBertForPreTraining,
       MobileBertForQuestionAnswering,
       MobileBertForSequenceClassification,
       MobileBertForTokenClassification,
       MobileBertModel,
   )






class 					lowerCamelCase_    :
  """simple docstring"""




  def __init__( self      :	Union[str, Any]			,	_a      :	Any			,	_a      :	Optional[Any]=13			,	_a      :	int=7			,	_a      :	Optional[int]=True			,	_a      :	Any=True			,	_a      :	Optional[int]=True			,	_a      :	str=True			,	_a      :	Union[str, Any]=99			,	_a      :	List[Any]=64			,	_a      :	Optional[Any]=32			,	_a      :	Optional[int]=5			,	_a      :	Optional[int]=4			,	_a      :	Union[str, Any]=37			,	_a      :	Optional[Any]="gelu"			,	_a      :	List[str]=0.1			,	_a      :	Tuple=0.1			,	_a      :	List[Any]=512			,	_a      :	Optional[Any]=16			,	_a      :	List[str]=2			,	_a      :	int=0.02			,	_a      :	Any=3			,	_a      :	int=4			,	_a      :	str=None			,	)					->					Optional[int]:
    __lowerCamelCase       :       List[Any]           = parent
    __lowerCamelCase       :       Union[str, Any]           = batch_size
    __lowerCamelCase       :       int           = seq_length
    __lowerCamelCase       :       Optional[Any]           = is_training
    __lowerCamelCase       :       str           = use_input_mask
    __lowerCamelCase       :       Any           = use_token_type_ids
    __lowerCamelCase       :       Any           = use_labels
    __lowerCamelCase       :       Dict           = vocab_size
    __lowerCamelCase       :       Any           = hidden_size
    __lowerCamelCase       :       int           = embedding_size
    __lowerCamelCase       :       Optional[int]           = num_hidden_layers
    __lowerCamelCase       :       Union[str, Any]           = num_attention_heads
    __lowerCamelCase       :       Union[str, Any]           = intermediate_size
    __lowerCamelCase       :       Union[str, Any]           = hidden_act
    __lowerCamelCase       :       Dict           = hidden_dropout_prob
    __lowerCamelCase       :       int           = attention_probs_dropout_prob
    __lowerCamelCase       :       List[Any]           = max_position_embeddings
    __lowerCamelCase       :       Tuple           = type_vocab_size
    __lowerCamelCase       :       int           = type_sequence_label_size
    __lowerCamelCase       :       List[str]           = initializer_range
    __lowerCamelCase       :       str           = num_labels
    __lowerCamelCase       :       Tuple           = num_choices
    __lowerCamelCase       :       Union[str, Any]           = scope




  def 						_lowercase     ( self      :	int   )					->					List[Any]:
    __lowerCamelCase       :       List[Any]           = ids_tensor([self.batch_size, self.seq_length]			,	self.vocab_size   )

    __lowerCamelCase       :       List[str]           = None
    if self.use_input_mask:
      __lowerCamelCase       :       Optional[Any]           = random_attention_mask([self.batch_size, self.seq_length]   )

    __lowerCamelCase       :       List[Any]           = None
    if self.use_token_type_ids:
      __lowerCamelCase       :       Union[str, Any]           = ids_tensor([self.batch_size, self.seq_length]			,	self.type_vocab_size   )

    __lowerCamelCase       :       int           = None
    __lowerCamelCase       :       Dict           = None
    __lowerCamelCase       :       Optional[Any]           = None
    if self.use_labels:
      __lowerCamelCase       :       Optional[int]           = ids_tensor([self.batch_size]			,	self.type_sequence_label_size   )
      __lowerCamelCase       :       Union[str, Any]           = ids_tensor([self.batch_size, self.seq_length]			,	self.num_labels   )
      __lowerCamelCase       :       int           = ids_tensor([self.batch_size]			,	self.num_choices   )

    __lowerCamelCase       :       Tuple           = self.get_config()

    return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




  def 						_lowercase     ( self      :	List[str]   )					->					Union[str, Any]:
    return MobileBertConfig(
        vocab_size=self.vocab_size			,	hidden_size=self.hidden_size			,	num_hidden_layers=self.num_hidden_layers			,	num_attention_heads=self.num_attention_heads			,	intermediate_size=self.intermediate_size			,	embedding_size=self.embedding_size			,	hidden_act=self.hidden_act			,	hidden_dropout_prob=self.hidden_dropout_prob			,	attention_probs_dropout_prob=self.attention_probs_dropout_prob			,	max_position_embeddings=self.max_position_embeddings			,	type_vocab_size=self.type_vocab_size			,	is_decoder=_a			,	initializer_range=self.initializer_range			,	)




  def 						_lowercase     ( self      :	Tuple			,	_a      :	Optional[int]			,	_a      :	Optional[int]			,	_a      :	List[Any]			,	_a      :	Dict			,	_a      :	Tuple			,	_a      :	Any			,	_a      :	Dict   )					->					Tuple:
    __lowerCamelCase       :       str           = MobileBertModel(config=_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       Dict           = model(_a			,	attention_mask=_a			,	token_type_ids=_a   )
    __lowerCamelCase       :       int           = model(_a			,	token_type_ids=_a   )
    __lowerCamelCase       :       Optional[int]           = model(_a   )

    self.parent.assertEqual(result.last_hidden_state.shape			,	(self.batch_size, self.seq_length, self.hidden_size)   )
    self.parent.assertEqual(result.pooler_output.shape			,	(self.batch_size, self.hidden_size)   )




  def 						_lowercase     ( self      :	Optional[int]			,	_a      :	int			,	_a      :	int			,	_a      :	int			,	_a      :	str			,	_a      :	Optional[int]			,	_a      :	str			,	_a      :	List[Any]   )					->					Optional[int]:
    __lowerCamelCase       :       Optional[int]           = MobileBertForMaskedLM(config=_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       List[str]           = model(_a			,	attention_mask=_a			,	token_type_ids=_a			,	labels=_a   )
    self.parent.assertEqual(result.logits.shape			,	(self.batch_size, self.seq_length, self.vocab_size)   )




  def 						_lowercase     ( self      :	List[str]			,	_a      :	List[Any]			,	_a      :	Dict			,	_a      :	Dict			,	_a      :	Union[str, Any]			,	_a      :	List[Any]			,	_a      :	Optional[Any]			,	_a      :	Optional[Any]   )					->					Tuple:
    __lowerCamelCase       :       Any           = MobileBertForNextSentencePrediction(config=_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       Dict           = model(
        _a			,	attention_mask=_a			,	token_type_ids=_a			,	labels=_a			,	)
    self.parent.assertEqual(result.logits.shape			,	(self.batch_size, 2)   )




  def 						_lowercase     ( self      :	List[str]			,	_a      :	Optional[int]			,	_a      :	Union[str, Any]			,	_a      :	Optional[Any]			,	_a      :	Any			,	_a      :	Optional[Any]			,	_a      :	str			,	_a      :	Tuple   )					->					Tuple:
    __lowerCamelCase       :       Any           = MobileBertForPreTraining(config=_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       int           = model(
        _a			,	attention_mask=_a			,	token_type_ids=_a			,	labels=_a			,	next_sentence_label=_a			,	)
    self.parent.assertEqual(result.prediction_logits.shape			,	(self.batch_size, self.seq_length, self.vocab_size)   )
    self.parent.assertEqual(result.seq_relationship_logits.shape			,	(self.batch_size, 2)   )




  def 						_lowercase     ( self      :	int			,	_a      :	int			,	_a      :	Union[str, Any]			,	_a      :	Dict			,	_a      :	Dict			,	_a      :	str			,	_a      :	Tuple			,	_a      :	Optional[Any]   )					->					int:
    __lowerCamelCase       :       str           = MobileBertForQuestionAnswering(config=_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       Any           = model(
        _a			,	attention_mask=_a			,	token_type_ids=_a			,	start_positions=_a			,	end_positions=_a			,	)
    self.parent.assertEqual(result.start_logits.shape			,	(self.batch_size, self.seq_length)   )
    self.parent.assertEqual(result.end_logits.shape			,	(self.batch_size, self.seq_length)   )




  def 						_lowercase     ( self      :	Union[str, Any]			,	_a      :	Dict			,	_a      :	str			,	_a      :	int			,	_a      :	Any			,	_a      :	Tuple			,	_a      :	str			,	_a      :	Union[str, Any]   )					->					str:
    __lowerCamelCase       :       Union[str, Any]           = self.num_labels
    __lowerCamelCase       :       Union[str, Any]           = MobileBertForSequenceClassification(_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       Optional[Any]           = model(_a			,	attention_mask=_a			,	token_type_ids=_a			,	labels=_a   )
    self.parent.assertEqual(result.logits.shape			,	(self.batch_size, self.num_labels)   )




  def 						_lowercase     ( self      :	str			,	_a      :	Union[str, Any]			,	_a      :	List[Any]			,	_a      :	Optional[Any]			,	_a      :	int			,	_a      :	Any			,	_a      :	Optional[int]			,	_a      :	Union[str, Any]   )					->					Any:
    __lowerCamelCase       :       str           = self.num_labels
    __lowerCamelCase       :       int           = MobileBertForTokenClassification(config=_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       List[Any]           = model(_a			,	attention_mask=_a			,	token_type_ids=_a			,	labels=_a   )
    self.parent.assertEqual(result.logits.shape			,	(self.batch_size, self.seq_length, self.num_labels)   )




  def 						_lowercase     ( self      :	Optional[int]			,	_a      :	Tuple			,	_a      :	Optional[Any]			,	_a      :	Dict			,	_a      :	Dict			,	_a      :	Any			,	_a      :	Dict			,	_a      :	List[Any]   )					->					Optional[Any]:
    __lowerCamelCase       :       Dict           = self.num_choices
    __lowerCamelCase       :       Union[str, Any]           = MobileBertForMultipleChoice(config=_a   )
    model.to(_a   )
    model.eval()
    __lowerCamelCase       :       List[str]           = input_ids.unsqueeze(1   ).expand(-1			,	self.num_choices			,	-1   ).contiguous()
    __lowerCamelCase       :       List[Any]           = token_type_ids.unsqueeze(1   ).expand(-1			,	self.num_choices			,	-1   ).contiguous()
    __lowerCamelCase       :       Any           = input_mask.unsqueeze(1   ).expand(-1			,	self.num_choices			,	-1   ).contiguous()
    __lowerCamelCase       :       List[str]           = model(
        _a			,	attention_mask=_a			,	token_type_ids=_a			,	labels=_a			,	)
    self.parent.assertEqual(result.logits.shape			,	(self.batch_size, self.num_choices)   )




  def 						_lowercase     ( self      :	List[str]   )					->					int:
    __lowerCamelCase       :       int           = self.prepare_config_and_inputs()
    (
        (
        __lowerCamelCase
    )       ,(
        __lowerCamelCase
    )       ,(
        __lowerCamelCase
    )       ,(
        __lowerCamelCase
    )       ,(
        __lowerCamelCase
    )       ,(
        __lowerCamelCase
    )       ,(
        __lowerCamelCase
    )       ,
    )       :       Optional[int]           = config_and_inputs
    __lowerCamelCase       :       List[Any]           = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
    return config, inputs_dict






@require_torch
class 					lowerCamelCase_    (				SCREAMING_SNAKE_CASE_   ,   SCREAMING_SNAKE_CASE_   ,   unittest.TestCase     ):
  """simple docstring"""




  a_												=(
      (
          MobileBertModel,
          MobileBertForMaskedLM,
          MobileBertForMultipleChoice,
          MobileBertForNextSentencePrediction,
          MobileBertForPreTraining,
          MobileBertForQuestionAnswering,
          MobileBertForSequenceClassification,
          MobileBertForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  a_												=(
      {
          """feature-extraction""": MobileBertModel,
          """fill-mask""": MobileBertForMaskedLM,
          """question-answering""": MobileBertForQuestionAnswering,
          """text-classification""": MobileBertForSequenceClassification,
          """token-classification""": MobileBertForTokenClassification,
          """zero-shot""": MobileBertForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  a_												=True




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

    if return_labels:
      if model_class in get_values(_a   ):
        __lowerCamelCase       :       Optional[Any]           = torch.zeros(
            (self.model_tester.batch_size, self.model_tester.seq_length)			,	dtype=torch.long			,	device=_a   )
        __lowerCamelCase       :       Any           = torch.zeros(
            self.model_tester.batch_size			,	dtype=torch.long			,	device=_a   )
    return inputs_dict




  def 						_lowercase     ( self      :	Tuple   )					->					List[Any]:
    __lowerCamelCase       :       Any           = MobileBertModelTester(self   )
    __lowerCamelCase       :       Any           = ConfigTester(self			,	config_class=_a			,	hidden_size=37   )




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




  def 						_lowercase     ( self      :	Dict   )					->					Union[str, Any]:
    __lowerCamelCase       :       Union[str, Any]           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_model(*_a   )




  def 						_lowercase     ( self      :	int   )					->					Dict:
    __lowerCamelCase       :       List[str]           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_masked_lm(*_a   )




  def 						_lowercase     ( self      :	Dict   )					->					str:
    __lowerCamelCase       :       List[Any]           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_multiple_choice(*_a   )




  def 						_lowercase     ( self      :	Dict   )					->					Union[str, Any]:
    __lowerCamelCase       :       Dict           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*_a   )




  def 						_lowercase     ( self      :	Any   )					->					str:
    __lowerCamelCase       :       Optional[Any]           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_pretraining(*_a   )




  def 						_lowercase     ( self      :	Union[str, Any]   )					->					Dict:
    __lowerCamelCase       :       int           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_question_answering(*_a   )




  def 						_lowercase     ( self      :	Optional[int]   )					->					List[str]:
    __lowerCamelCase       :       int           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_sequence_classification(*_a   )




  def 						_lowercase     ( self      :	List[Any]   )					->					List[Any]:
    __lowerCamelCase       :       List[Any]           = self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_mobilebert_for_token_classification(*_a   )




def        a_     (							_lowerCAmelCase       )      ->      Union[str, Any]:
  return torch.tensor(
      _lowerCAmelCase       ,dtype=torch.long       ,device=_lowerCAmelCase       ,)


_UpperCamelCase											=						1e-3






@require_torch
@require_sentencepiece
@require_tokenizers
class 					lowerCamelCase_    (				unittest.TestCase     ):
  """simple docstring"""




  @slow
  def 						_lowercase     ( self      :	int   )					->					List[str]:
    __lowerCamelCase       :       Any           = MobileBertModel.from_pretrained('google/mobilebert-uncased'   ).to(_a   )
    __lowerCamelCase       :       Optional[Any]           = _long_tensor([[101, 7110, 1005, 1056, 2023, 1_1333, 1_7413, 1029, 102]]   )
    with torch.no_grad():
      __lowerCamelCase       :       List[Any]           = model(_a   )[0]
    __lowerCamelCase       :       Tuple           = torch.Size((1, 9, 512)   )
    self.assertEqual(output.shape			,	_a   )
    __lowerCamelCase       :       int           = torch.tensor(
        [
            [
                [-2.4_736_526e07, 8.2_691_656e04, 1.6_521_838e05],
                [-5.7_541_704e-01, 3.9_056_022e00, 4.4_011_507e00],
                [2.6_047_359e00, 1.5_677_652e00, -1.7_324_188e-01],
            ]
        ]			,	device=_a			,	)

    # MobileBERT results range from 10e0 to 10e8. Even a 0.0000001% difference with a value of 10e8 results in a
    # ~1 difference, it's therefore not a good idea to measure using addition.
    # Here, we instead divide the expected result with the result in order to obtain ~1. We then check that the
    # result is held between bounds: 1 - TOLERANCE < expected_result / result < 1 + TOLERANCE
    __lowerCamelCase       :       List[Any]           = torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE   )
    __lowerCamelCase       :       Tuple           = torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE   )

    self.assertTrue(lower_bound and upper_bound   )











'''simple docstring'''





import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available






class 					lowerCamelCase_    (				SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




  a_												=["""image_processor""", """tokenizer"""]
  a_												="""OwlViTImageProcessor"""
  a_												=("""CLIPTokenizer""", """CLIPTokenizerFast""")




  def __init__( self      :	Any			,	_a      :	str=None			,	_a      :	Optional[Any]=None			,	**_a      :	int   )					->					List[str]:
    __lowerCamelCase       :       List[Any]           = None
    if "feature_extractor" in kwargs:
      warnings.warn(
          'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
          ' instead.'			,	_a			,	)
      __lowerCamelCase       :       Tuple           = kwargs.pop('feature_extractor'   )

    __lowerCamelCase       :       int           = image_processor if image_processor is not None else feature_extractor
    if image_processor is None:
      raise ValueError('You need to specify an `image_processor`.'   )
    if tokenizer is None:
      raise ValueError('You need to specify a `tokenizer`.'   )

    super().__init__(_a			,	_a   )




  def __call__( self      :	Tuple			,	_a      :	Tuple=None			,	_a      :	int=None			,	_a      :	List[Any]=None			,	_a      :	List[Any]="max_length"			,	_a      :	Union[str, Any]="np"			,	**_a      :	Union[str, Any]   )					->					List[str]:

    if text is None and query_images is None and images is None:
      raise ValueError(
          'You have to specify at least one text or query image or image. All three cannot be none.'   )

    if text is not None:
      if isinstance(_a			,	_a   ) or (isinstance(_a			,	_a   ) and not isinstance(text[0]			,	_a   )):
        __lowerCamelCase       :       Any           = [self.tokenizer(_a			,	padding=_a			,	return_tensors=_a			,	**_a   )]

      elif isinstance(_a			,	_a   ) and isinstance(text[0]			,	_a   ):
        __lowerCamelCase       :       List[Any]           = []

        # Maximum number of queries across batch
        __lowerCamelCase       :       str           = max([len(_a   ) for t in text]   )

        # Pad all batch samples to max number of text queries
        for t in text:
          if len(_a   ) != max_num_queries:
            __lowerCamelCase       :       List[Any]           = t + [' '] * (max_num_queries - len(_a   ))

          __lowerCamelCase       :       Dict           = self.tokenizer(_a			,	padding=_a			,	return_tensors=_a			,	**_a   )
          encodings.append(_a   )
      else:
        raise TypeError('Input text should be a string, a list of strings or a nested list of strings'   )

      if return_tensors == "np":
        __lowerCamelCase       :       Optional[Any]           = np.concatenate([encoding['input_ids'] for encoding in encodings]			,	axis=0   )
        __lowerCamelCase       :       str           = np.concatenate([encoding['attention_mask'] for encoding in encodings]			,	axis=0   )

      elif return_tensors == "jax" and is_flax_available():
        import jax.numpy as jnp

        __lowerCamelCase       :       int           = jnp.concatenate([encoding['input_ids'] for encoding in encodings]			,	axis=0   )
        __lowerCamelCase       :       List[str]           = jnp.concatenate([encoding['attention_mask'] for encoding in encodings]			,	axis=0   )

      elif return_tensors == "pt" and is_torch_available():
        import torch

        __lowerCamelCase       :       str           = torch.cat([encoding['input_ids'] for encoding in encodings]			,	dim=0   )
        __lowerCamelCase       :       Optional[Any]           = torch.cat([encoding['attention_mask'] for encoding in encodings]			,	dim=0   )

      elif return_tensors == "tf" and is_tf_available():
        import tensorflow as tf

        __lowerCamelCase       :       List[Any]           = tf.stack([encoding['input_ids'] for encoding in encodings]			,	axis=0   )
        __lowerCamelCase       :       int           = tf.stack([encoding['attention_mask'] for encoding in encodings]			,	axis=0   )

      else:
        raise ValueError('Target return tensor type could not be returned'   )

      __lowerCamelCase       :       Any           = BatchEncoding()
      __lowerCamelCase       :       Dict           = input_ids
      __lowerCamelCase       :       str           = attention_mask

    if query_images is not None:
      __lowerCamelCase       :       Optional[int]           = BatchEncoding()
      __lowerCamelCase       :       List[Any]           = self.image_processor(
          _a			,	return_tensors=_a			,	**_a   ).pixel_values
      __lowerCamelCase       :       str           = query_pixel_values

    if images is not None:
      __lowerCamelCase       :       Union[str, Any]           = self.image_processor(_a			,	return_tensors=_a			,	**_a   )

    if text is not None and images is not None:
      __lowerCamelCase       :       Tuple           = image_features.pixel_values
      return encoding
    elif query_images is not None and images is not None:
      __lowerCamelCase       :       Tuple           = image_features.pixel_values
      return encoding
    elif text is not None or query_images is not None:
      return encoding
    else:
      return BatchEncoding(data=dict(**_a   )			,	tensor_type=_a   )




  def 						_lowercase     ( self      :	Optional[Any]			,	*_a      :	List[str]			,	**_a      :	Dict   )					->					int:
    return self.image_processor.post_process(*_a			,	**_a   )




  def 						_lowercase     ( self      :	str			,	*_a      :	str			,	**_a      :	List[str]   )					->					int:
    return self.image_processor.post_process_object_detection(*_a			,	**_a   )




  def 						_lowercase     ( self      :	int			,	*_a      :	List[Any]			,	**_a      :	Optional[int]   )					->					str:
    return self.image_processor.post_process_image_guided_detection(*_a			,	**_a   )




  def 						_lowercase     ( self      :	Tuple			,	*_a      :	Optional[Any]			,	**_a      :	List[Any]   )					->					Tuple:
    return self.tokenizer.batch_decode(*_a			,	**_a   )




  def 						_lowercase     ( self      :	str			,	*_a      :	Optional[Any]			,	**_a      :	str   )					->					Union[str, Any]:
    return self.tokenizer.decode(*_a			,	**_a   )




  @property
  def 						_lowercase     ( self      :	Any   )					->					Any:
    warnings.warn(
        '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'			,	_a			,	)
    return self.image_processor_class




  @property
  def 						_lowercase     ( self      :	Union[str, Any]   )					->					Any:
    warnings.warn(
        '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'			,	_a			,	)
    return self.image_processor






