

"""simple docstring"""





from __future__ import annotations

import unittest

from transformers import DistilBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
   import tensorflow as tf

   from transformers.models.distilbert.modeling_tf_distilbert import (
       TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFDistilBertForMaskedLM,
       TFDistilBertForMultipleChoice,
       TFDistilBertForQuestionAnswering,
       TFDistilBertForSequenceClassification,
       TFDistilBertForTokenClassification,
       TFDistilBertModel,
   )




class 					_lowerCAmelCase  :







 """simple docstring"""







 def __init__(			self							:			List[str],					UpperCAmelCase__							:			Tuple,					):
    __lowercase								=						parent
    __lowercase								=						1_3
    __lowercase								=						7
    __lowercase								=						True
    __lowercase								=						True
    __lowercase								=						False
    __lowercase								=						True
    __lowercase								=						9_9
    __lowercase								=						3_2
    __lowercase								=						2
    __lowercase								=						4
    __lowercase								=						3_7
    __lowercase								=						"gelu"
    __lowercase								=						0.1
    __lowercase								=						0.1
    __lowercase								=						5_1_2
    __lowercase								=						1_6
    __lowercase								=						2
    __lowercase								=						0.02
    __lowercase								=						3
    __lowercase								=						4
    __lowercase								=						None


 def 					_lowercase (			self							:			int	):
    __lowercase								=						ids_tensor([self.batch_size, self.seq_length],					self.vocab_size	)

    __lowercase								=						None
    if self.use_input_mask:
       __lowercase								=						random_attention_mask([self.batch_size, self.seq_length]	)

    __lowercase								=						None
    __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.seq_length],					self.num_labels	)
       __lowercase								=						ids_tensor([self.batch_size],					self.num_choices	)

    __lowercase								=						DistilBertConfig(
        vocab_size=self.vocab_size,					dim=self.hidden_size,					n_layers=self.num_hidden_layers,					n_heads=self.num_attention_heads,					hidden_dim=self.intermediate_size,					hidden_act=self.hidden_act,					dropout=self.hidden_dropout_prob,					attention_dropout=self.attention_probs_dropout_prob,					max_position_embeddings=self.max_position_embeddings,					initializer_range=self.initializer_range,					)

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


 def 					_lowercase (			self							:			Union[str, Any],					UpperCAmelCase__							:			str,					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			int,					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			Optional[int]	):
    __lowercase								=						TFDistilBertModel(config=UpperCAmelCase__	)
    __lowercase								=						{"input_ids": input_ids, "attention_mask": input_mask}

    __lowercase								=						model(UpperCAmelCase__	)

    __lowercase								=						[input_ids, input_mask]

    __lowercase								=						model(UpperCAmelCase__	)

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


 def 					_lowercase (			self							:			Tuple,					UpperCAmelCase__							:			Optional[Any],					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			Tuple,					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			Union[str, Any],					UpperCAmelCase__							:			List[str]	):
    __lowercase								=						TFDistilBertForMaskedLM(config=UpperCAmelCase__	)
    __lowercase								=						{"input_ids": input_ids, "attention_mask": input_mask}
    __lowercase								=						model(UpperCAmelCase__	)
    self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.seq_length, self.vocab_size)	)


 def 					_lowercase (			self							:			int,					UpperCAmelCase__							:			Optional[Any],					UpperCAmelCase__							:			List[str],					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			Any	):
    __lowercase								=						TFDistilBertForQuestionAnswering(config=UpperCAmelCase__	)
    __lowercase								=						{
        "input_ids": input_ids,
        "attention_mask": input_mask,
    }
    __lowercase								=						model(UpperCAmelCase__	)
    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							:			Any,					UpperCAmelCase__							:			Optional[int],					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			Optional[int],					UpperCAmelCase__							:			List[Any],					UpperCAmelCase__							:			List[str],					UpperCAmelCase__							:			Any	):
    __lowercase								=						self.num_labels
    __lowercase								=						TFDistilBertForSequenceClassification(UpperCAmelCase__	)
    __lowercase								=						{"input_ids": input_ids, "attention_mask": input_mask}
    __lowercase								=						model(UpperCAmelCase__	)
    self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.num_labels)	)


 def 					_lowercase (			self							:			Optional[int],					UpperCAmelCase__							:			str,					UpperCAmelCase__							:			Optional[int],					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			int,					UpperCAmelCase__							:			List[Any],					UpperCAmelCase__							:			Tuple	):
    __lowercase								=						self.num_choices
    __lowercase								=						TFDistilBertForMultipleChoice(UpperCAmelCase__	)
    __lowercase								=						tf.tile(tf.expand_dims(UpperCAmelCase__,					1	),					(1, self.num_choices, 1)	)
    __lowercase								=						tf.tile(tf.expand_dims(UpperCAmelCase__,					1	),					(1, self.num_choices, 1)	)
    __lowercase								=						{
        "input_ids": multiple_choice_inputs_ids,
        "attention_mask": multiple_choice_input_mask,
    }
    __lowercase								=						model(UpperCAmelCase__	)
    self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.num_choices)	)


 def 					_lowercase (			self							:			str,					UpperCAmelCase__							:			Union[str, Any],					UpperCAmelCase__							:			str,					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			Optional[int],					UpperCAmelCase__							:			int,					UpperCAmelCase__							:			List[Any]	):
    __lowercase								=						self.num_labels
    __lowercase								=						TFDistilBertForTokenClassification(UpperCAmelCase__	)
    __lowercase								=						{"input_ids": input_ids, "attention_mask": input_mask}
    __lowercase								=						model(UpperCAmelCase__	)
    self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.seq_length, self.num_labels)	)



 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						self.prepare_config_and_inputs()
    ((__lowercase)		,(__lowercase)		,(__lowercase)		,(__lowercase)		,(__lowercase)		,(__lowercase))								=						config_and_inputs
    __lowercase								=						{"input_ids": input_ids, "attention_mask": input_mask}
    return config, inputs_dict







@require_tf
class 					_lowerCAmelCase  (	lowercase     ,lowercase     ,unittest.TestCase   ):







 """simple docstring"""







 __UpperCAmelCase	:					int   		=	(
     (
         TFDistilBertModel,
         TFDistilBertForMaskedLM,
         TFDistilBertForQuestionAnswering,
         TFDistilBertForSequenceClassification,
         TFDistilBertForTokenClassification,
         TFDistilBertForMultipleChoice,
     )
     if is_tf_available()
     else None
 )
 __UpperCAmelCase	:					Union[str, Any]   		=	(
     {
         "feature-extraction": TFDistilBertModel,
         "fill-mask": TFDistilBertForMaskedLM,
         "question-answering": TFDistilBertForQuestionAnswering,
         "text-classification": TFDistilBertForSequenceClassification,
         "token-classification": TFDistilBertForTokenClassification,
         "zero-shot": TFDistilBertForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 __UpperCAmelCase	:					str   		=	False
 __UpperCAmelCase	:					List[str]   		=	False


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase								=						TFDistilBertModelTester(self	)
    __lowercase								=						ConfigTester(self,					config_class=UpperCAmelCase__,					dim=3_7	)


 def 					_lowercase (			self							:			str	):
    self.config_tester.run_common_tests()


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_distilbert_model(*UpperCAmelCase__	)


 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_distilbert_for_masked_lm(*UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[Any]	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_distilbert_for_question_answering(*UpperCAmelCase__	)


 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_distilbert_for_sequence_classification(*UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[str]	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_distilbert_for_multiple_choice(*UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[str]	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_distilbert_for_token_classification(*UpperCAmelCase__	)



 @slow
 def 					_lowercase (			self							:			str	):
    for model_name in list(TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]	):
       __lowercase								=						TFDistilBertModel.from_pretrained(UpperCAmelCase__	)
       self.assertIsNotNone(UpperCAmelCase__	)







@require_tf
class 					_lowerCAmelCase  (	unittest.TestCase   ):







 """simple docstring"""







 @slow
 def 					_lowercase (			self							:			Union[str, Any]	):
    __lowercase								=						TFDistilBertModel.from_pretrained("distilbert-base-uncased"	)
    __lowercase								=						tf.constant([[0, 1, 2, 3, 4, 5]]	)
    __lowercase								=						model(UpperCAmelCase__	)[0]

    __lowercase								=						[1, 6, 7_6_8]
    self.assertEqual(output.shape,					UpperCAmelCase__	)

    __lowercase								=						tf.constant(
        [
            [
                [0.19_261_885, -0.13_732_955, 0.4_119_799],
                [0.22_150_156, -0.07_422_661, 0.39_037_204],
                [0.22_756_018, -0.0_896_414, 0.3_701_467],
            ]
        ]	)
    tf.debugging.assert_near(output[:, :3, :3],					UpperCAmelCase__,					atol=1E-4	)












"""simple docstring"""






from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
  import PIL

UpperCAmelCase_   : int   			= logging.get_logger(__name__)



def 					_A			(__a							) ->       List[List[ImageInput]]:
    """simple docstring"""






    if isinstance(__a    ,				(list, tuple)							) and isinstance(videos[0]    ,				(list, tuple)							) and is_valid_image(videos[0][0]							):
        return videos

    elif isinstance(__a    ,				(list, tuple)							) and is_valid_image(videos[0]							):
        return [videos]

    elif is_valid_image(__a							):
        return [[videos]]

    raise ValueError(f'Could not make batched video from {videos}'							)





class 							lowerCAmelCase__				(			UpperCAmelCase__ ):






      '''simple docstring'''

      __UpperCamelCase	 =  ["pixel_values"]
      def __init__(						self     :  Dict						,	lowercase_     :  bool = True						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  PILImageResampling = PILImageResampling.BILINEAR						,	lowercase_     :  bool = True						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  bool = True						,	lowercase_     :  Union[int, float] = 1 / 255						,	lowercase_     :  bool = True						,	lowercase_     :  bool = True						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	**lowercase_     :  Dict						,	):




          '''simple docstring'''


          super().__init__(**lowercase_)
          SCREAMING_SNAKE_CASE_      :  str    						=		size if size is not None else {'''shortest_edge''': 256}
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		get_size_dict(lowercase_						,	default_to_square=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
          SCREAMING_SNAKE_CASE_      :  Dict    						=		get_size_dict(lowercase_						,	param_name='''crop_size''')

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		do_resize
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		do_center_crop
          SCREAMING_SNAKE_CASE_      :  Dict    						=		crop_size
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		resample
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		do_rescale
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		rescale_factor
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		offset
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		do_normalize
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		image_std if image_std is not None else IMAGENET_STANDARD_STD
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]						,	lowercase_     :  np.ndarray						,	lowercase_     :  Dict[str, int]						,	lowercase_     :  PILImageResampling = PILImageResampling.BILINEAR						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  Any						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Tuple    						=		get_size_dict(lowercase_						,	default_to_square=lowercase_)
          if "shortest_edge" in size:
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		get_resize_output_image_size(lowercase_						,	size['''shortest_edge''']						,	default_to_square=lowercase_)
          elif "height" in size and "width" in size:
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		(size['''height'''], size['''width'''])
          else:
              raise ValueError(F'Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}')
          return resize(lowercase_						,	size=lowercase_						,	resample=lowercase_						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Any						,	lowercase_     :  np.ndarray						,	lowercase_     :  Dict[str, int]						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  List[Any]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		get_size_dict(lowercase_)
          if "height" not in size or "width" not in size:
              raise ValueError(F'Size must have \'height\' and \'width\' as keys. Got {size.keys()}')
          return center_crop(lowercase_						,	size=(size['''height'''], size['''width'''])						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]						,	lowercase_     :  np.ndarray						,	lowercase_     :  Union[int, float]						,	lowercase_     :  bool = True						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  Optional[int]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image.astype(np.floataa)
          if offset:
              SCREAMING_SNAKE_CASE_      :  Tuple    						=		image - (scale / 2)
          return rescale(lowercase_						,	scale=lowercase_						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]						,	lowercase_     :  np.ndarray						,	lowercase_     :  Union[float, List[float]]						,	lowercase_     :  Union[float, List[float]]						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  List[str]						,	):




          '''simple docstring'''


          return normalize(lowercase_						,	mean=lowercase_						,	std=lowercase_						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]						,	lowercase_     :  ImageInput						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  PILImageResampling = None						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  bool = None						,	lowercase_     :  float = None						,	lowercase_     :  bool = None						,	lowercase_     :  bool = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[ChannelDimension] = ChannelDimension.FIRST						,	):




          '''simple docstring'''


          if do_resize and size is None or resample is None:
              raise ValueError('''Size and resample must be specified if do_resize is True.''')

          if do_center_crop and crop_size is None:
              raise ValueError('''Crop size must be specified if do_center_crop is True.''')

          if do_rescale and rescale_factor is None:
              raise ValueError('''Rescale factor must be specified if do_rescale is True.''')

          if do_normalize and (image_mean is None or image_std is None):
              raise ValueError('''Image mean and std must be specified if do_normalize is True.''')

          if offset and not do_rescale:
              raise ValueError('''For offset, do_rescale must also be set to True.''')

          # All transformations expect numpy arrays.
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		to_numpy_array(lowercase_)

          if do_resize:
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		self.resize(image=lowercase_						,	size=lowercase_						,	resample=lowercase_)

          if do_center_crop:
              SCREAMING_SNAKE_CASE_      :  Dict    						=		self.center_crop(lowercase_						,	size=lowercase_)

          if do_rescale:
              SCREAMING_SNAKE_CASE_      :  int    						=		self.rescale(image=lowercase_						,	scale=lowercase_						,	offset=lowercase_)

          if do_normalize:
              SCREAMING_SNAKE_CASE_      :  Dict    						=		self.normalize(image=lowercase_						,	mean=lowercase_						,	std=lowercase_)

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		to_channel_dimension_format(lowercase_						,	lowercase_)
          return image



      def _SCREAMING_SNAKE_CASE (						self     :  Dict						,	lowercase_     :  ImageInput						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  PILImageResampling = None						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  bool = None						,	lowercase_     :  float = None						,	lowercase_     :  bool = None						,	lowercase_     :  bool = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[Union[str, TensorType]] = None						,	lowercase_     :  ChannelDimension = ChannelDimension.FIRST						,	**lowercase_     :  Optional[Any]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		do_resize if do_resize is not None else self.do_resize
          SCREAMING_SNAKE_CASE_      :  int    						=		resample if resample is not None else self.resample
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		do_center_crop if do_center_crop is not None else self.do_center_crop
          SCREAMING_SNAKE_CASE_      :  Dict    						=		do_rescale if do_rescale is not None else self.do_rescale
          SCREAMING_SNAKE_CASE_      :  Dict    						=		rescale_factor if rescale_factor is not None else self.rescale_factor
          SCREAMING_SNAKE_CASE_      :  Dict    						=		offset if offset is not None else self.offset
          SCREAMING_SNAKE_CASE_      :  str    						=		do_normalize if do_normalize is not None else self.do_normalize
          SCREAMING_SNAKE_CASE_      :  Dict    						=		image_mean if image_mean is not None else self.image_mean
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		image_std if image_std is not None else self.image_std

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		size if size is not None else self.size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		get_size_dict(lowercase_						,	default_to_square=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Any    						=		crop_size if crop_size is not None else self.crop_size
          SCREAMING_SNAKE_CASE_      :  Dict    						=		get_size_dict(lowercase_						,	param_name='''crop_size''')

          if not valid_images(lowercase_):
              raise ValueError(
                  '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
                  '''torch.Tensor, tf.Tensor or jax.ndarray.''')

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		make_batched(lowercase_)

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		[
              [
                  self._preprocess_image(
                      image=lowercase_						,	do_resize=lowercase_						,	size=lowercase_						,	resample=lowercase_						,	do_center_crop=lowercase_						,	crop_size=lowercase_						,	do_rescale=lowercase_						,	rescale_factor=lowercase_						,	offset=lowercase_						,	do_normalize=lowercase_						,	image_mean=lowercase_						,	image_std=lowercase_						,	data_format=lowercase_						,	)
                  for img in video
              ]
              for video in videos
          ]

          SCREAMING_SNAKE_CASE_      :  int    						=		{'''pixel_values''': videos}
          return BatchFeature(data=lowercase_						,	tensor_type=lowercase_)


