





from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


__lowerCAmelCase :List[Any]     =    logging.get_logger(__name__)


if is_vision_available():
							import PIL






class        _a(    __A    ):
		lowerCamelCase__     :Optional[Any]   				=		['pixel_values']







		def __init__(    self ,						__snake_case = True ,						__snake_case = None ,						__snake_case = PILImageResampling.BICUBIC ,						__snake_case = True ,						__snake_case = None ,						__snake_case = True ,						__snake_case = 1 / 2_5_5 ,						__snake_case = True ,						__snake_case = None ,						__snake_case = None ,						__snake_case = True ,						**__snake_case ,						)      ->      None:


							'''simple docstring'''

							super().__init__(**__snake_case				)
							_snake_case       :					str				       =   size if size is not None else {"shortest_edge": 2_2_4}
							_snake_case       :					str				       =   get_size_dict(__snake_case ,						default_to_square=__snake_case				)
							_snake_case       :					List[str]				       =   crop_size if crop_size is not None else {"height": 2_2_4, "width": 2_2_4}
							_snake_case       :					List[str]				       =   get_size_dict(__snake_case ,						default_to_square=__snake_case ,						param_name="crop_size"				)

							_snake_case       :					Tuple				       =   do_resize
							_snake_case       :					Union[str, Any]				       =   size
							_snake_case       :					int				       =   resample
							_snake_case       :					int				       =   do_center_crop
							_snake_case       :					Dict				       =   crop_size
							_snake_case       :					List[Any]				       =   do_rescale
							_snake_case       :					Tuple				       =   rescale_factor
							_snake_case       :					List[Any]				       =   do_normalize
							_snake_case       :					Optional[int]				       =   image_mean if image_mean is not None else OPENAI_CLIP_MEAN
							_snake_case       :					str				       =   image_std if image_std is not None else OPENAI_CLIP_STD
							_snake_case       :					Tuple				       =   do_convert_rgb







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case = PILImageResampling.BICUBIC ,						__snake_case = None ,						**__snake_case ,						)      ->      np.ndarray:


							'''simple docstring'''

							_snake_case       :					int				       =   get_size_dict(__snake_case ,						default_to_square=__snake_case				)
							if "shortest_edge" not in size:
												raise ValueError(f"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""				)
							_snake_case       :					str				       =   get_resize_output_image_size(__snake_case ,						size=size["shortest_edge"] ,						default_to_square=__snake_case				)
							return resize(__snake_case ,						size=__snake_case ,						resample=__snake_case ,						data_format=__snake_case ,						**__snake_case				)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case = None ,						**__snake_case ,						)      ->      np.ndarray:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   get_size_dict(__snake_case				)
							if "height" not in size or "width" not in size:
												raise ValueError(f"""The `size` parameter must contain the keys (height, width). Got {size.keys()}"""				)
							return center_crop(__snake_case ,						size=(size["height"], size["width"]) ,						data_format=__snake_case ,						**__snake_case				)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case = None ,						**__snake_case ,						)      ->      Optional[Any]:


							'''simple docstring'''

							return rescale(__snake_case ,						scale=__snake_case ,						data_format=__snake_case ,						**__snake_case				)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case = None ,						**__snake_case ,						)      ->      np.ndarray:


							'''simple docstring'''

							return normalize(__snake_case ,						mean=__snake_case ,						std=__snake_case ,						data_format=__snake_case ,						**__snake_case				)







		def        lowercase       (    self ,						__snake_case ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = None ,						__snake_case = ChannelDimension.FIRST ,						**__snake_case ,						)      ->      PIL.Image.Image:


							'''simple docstring'''

							_snake_case       :					Union[str, Any]				       =   do_resize if do_resize is not None else self.do_resize
							_snake_case       :					int				       =   size if size is not None else self.size
							_snake_case       :					int				       =   get_size_dict(__snake_case ,						param_name="size" ,						default_to_square=__snake_case				)
							_snake_case       :					str				       =   resample if resample is not None else self.resample
							_snake_case       :					Dict				       =   do_center_crop if do_center_crop is not None else self.do_center_crop
							_snake_case       :					Any				       =   crop_size if crop_size is not None else self.crop_size
							_snake_case       :					Union[str, Any]				       =   get_size_dict(__snake_case ,						param_name="crop_size" ,						default_to_square=__snake_case				)
							_snake_case       :					Any				       =   do_rescale if do_rescale is not None else self.do_rescale
							_snake_case       :					Optional[Any]				       =   rescale_factor if rescale_factor is not None else self.rescale_factor
							_snake_case       :					Dict				       =   do_normalize if do_normalize is not None else self.do_normalize
							_snake_case       :					Optional[int]				       =   image_mean if image_mean is not None else self.image_mean
							_snake_case       :					List[str]				       =   image_std if image_std is not None else self.image_std
							_snake_case       :					Tuple				       =   do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

							_snake_case       :					List[str]				       =   make_list_of_images(__snake_case				)

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

							if do_resize and size is None:
												raise ValueError("Size 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."				)

							# PIL RGBA images are converted to RGB
							if do_convert_rgb:
												_snake_case       :					List[str]				       =   [convert_to_rgb(__snake_case				) for image in images]

							# All transformations expect numpy arrays.
							_snake_case       :					List[Any]				       =   [to_numpy_array(__snake_case				) for image in images]

							if do_resize:
												_snake_case       :					List[Any]				       =   [self.resize(image=__snake_case ,						size=__snake_case ,						resample=__snake_case				) for image in images]

							if do_center_crop:
												_snake_case       :					Any				       =   [self.center_crop(image=__snake_case ,						size=__snake_case				) for image in images]

							if do_rescale:
												_snake_case       :					int				       =   [self.rescale(image=__snake_case ,						scale=__snake_case				) for image in images]

							if do_normalize:
												_snake_case       :					int				       =   [self.normalize(image=__snake_case ,						mean=__snake_case ,						std=__snake_case				) for image in images]

							_snake_case       :					Union[str, Any]				       =   [to_channel_dimension_format(__snake_case ,						__snake_case				) for image in images]

							_snake_case       :					Any				       =   {"pixel_values": images}
							return BatchFeature(data=__snake_case ,						tensor_type=__snake_case				)






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        _a:







		def __init__(    self ,						__snake_case ,						)      ->      List[str]:


							'''simple docstring'''

							_snake_case       :					Dict				       =   parent
							_snake_case       :					Any				       =   1_3
							_snake_case       :					Union[str, Any]				       =   7
							_snake_case       :					Any				       =   True
							_snake_case       :					Optional[Any]				       =   True
							_snake_case       :					List[str]				       =   False
							_snake_case       :					str				       =   True
							_snake_case       :					int				       =   9_9
							_snake_case       :					Optional[int]				       =   3_2
							_snake_case       :					Dict				       =   2
							_snake_case       :					Optional[Any]				       =   4
							_snake_case       :					Any				       =   3_7
							_snake_case       :					Optional[int]				       =   "gelu"
							_snake_case       :					Optional[Any]				       =   0.1
							_snake_case       :					List[Any]				       =   0.1
							_snake_case       :					Any				       =   5_1_2
							_snake_case       :					Optional[int]				       =   1_6
							_snake_case       :					Dict				       =   2
							_snake_case       :					Optional[int]				       =   0.02
							_snake_case       :					Any				       =   3
							_snake_case       :					Tuple				       =   4
							_snake_case       :					str				       =   None







		def        lowercase       (    self				)      ->      Union[str, Any]:


							'''simple docstring'''

							_snake_case       :					Optional[int]				       =   ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size				)

							_snake_case       :					List[Any]				       =   None
							if self.use_input_mask:
												_snake_case       :					Tuple				       =   random_attention_mask([self.batch_size, self.seq_length]				)

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

							_snake_case       :					Optional[Any]				       =   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 ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      Tuple:


							'''simple docstring'''

							_snake_case       :					str				       =   TFDistilBertModel(config=__snake_case				)
							_snake_case       :					Dict				       =   {"input_ids": input_ids, "attention_mask": input_mask}

							_snake_case       :					Union[str, Any]				       =   model(__snake_case				)

							_snake_case       :					Union[str, Any]				       =   [input_ids, input_mask]

							_snake_case       :					int				       =   model(__snake_case				)

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







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      str:


							'''simple docstring'''

							_snake_case       :					str				       =   TFDistilBertForMaskedLM(config=__snake_case				)
							_snake_case       :					Optional[Any]				       =   {"input_ids": input_ids, "attention_mask": input_mask}
							_snake_case       :					Tuple				       =   model(__snake_case				)
							self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size)				)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      Union[str, Any]:


							'''simple docstring'''

							_snake_case       :					int				       =   TFDistilBertForQuestionAnswering(config=__snake_case				)
							_snake_case       :					Any				       =   {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							}
							_snake_case       :					Tuple				       =   model(__snake_case				)
							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 ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      str:


							'''simple docstring'''

							_snake_case       :					Dict				       =   self.num_labels
							_snake_case       :					Dict				       =   TFDistilBertForSequenceClassification(__snake_case				)
							_snake_case       :					Dict				       =   {"input_ids": input_ids, "attention_mask": input_mask}
							_snake_case       :					Optional[Any]				       =   model(__snake_case				)
							self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_labels)				)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      Dict:


							'''simple docstring'''

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







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      Dict:


							'''simple docstring'''

							_snake_case       :					List[str]				       =   self.num_labels
							_snake_case       :					int				       =   TFDistilBertForTokenClassification(__snake_case				)
							_snake_case       :					Any				       =   {"input_ids": input_ids, "attention_mask": input_mask}
							_snake_case       :					Any				       =   model(__snake_case				)
							self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.num_labels)				)







		def        lowercase       (    self				)      ->      Tuple:


							'''simple docstring'''

							_snake_case       :					List[str]				       =   self.prepare_config_and_inputs()
							((_snake_case)       , (_snake_case)       , (_snake_case)       , (_snake_case)       , (_snake_case)       , (_snake_case))       :					List[str]				       =   config_and_inputs
							_snake_case       :					Optional[int]				       =   {"input_ids": input_ids, "attention_mask": input_mask}
							return config, inputs_dict






@require_tf
class        _a(    __A	,   __A	,   unittest.TestCase    ):
		lowerCamelCase__     :str   				=		(
		    (
		        TFDistilBertModel,
		        TFDistilBertForMaskedLM,
		        TFDistilBertForQuestionAnswering,
		        TFDistilBertForSequenceClassification,
		        TFDistilBertForTokenClassification,
		        TFDistilBertForMultipleChoice,
		    )
		    if is_tf_available()
		    else None
		)
		lowerCamelCase__     :Tuple   				=		(
		    {
		        'feature-extraction': TFDistilBertModel,
		        'fill-mask': TFDistilBertForMaskedLM,
		        'question-answering': TFDistilBertForQuestionAnswering,
		        'text-classification': TFDistilBertForSequenceClassification,
		        'token-classification': TFDistilBertForTokenClassification,
		        'zero-shot': TFDistilBertForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		lowerCamelCase__     :Tuple   				=		False
		lowerCamelCase__     :Any   				=		False







		def        lowercase       (    self				)      ->      int:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   TFDistilBertModelTester(self				)
							_snake_case       :					str				       =   ConfigTester(self ,						config_class=__snake_case ,						dim=3_7				)







		def        lowercase       (    self				)      ->      List[Any]:


							'''simple docstring'''

							self.config_tester.run_common_tests()







		def        lowercase       (    self				)      ->      List[Any]:


							'''simple docstring'''

							_snake_case       :					Dict				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_distilbert_model(*__snake_case				)







		def        lowercase       (    self				)      ->      Any:


							'''simple docstring'''

							_snake_case       :					Any				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_distilbert_for_masked_lm(*__snake_case				)







		def        lowercase       (    self				)      ->      List[str]:


							'''simple docstring'''

							_snake_case       :					str				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_distilbert_for_question_answering(*__snake_case				)







		def        lowercase       (    self				)      ->      Dict:


							'''simple docstring'''

							_snake_case       :					List[Any]				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_distilbert_for_sequence_classification(*__snake_case				)







		def        lowercase       (    self				)      ->      Dict:


							'''simple docstring'''

							_snake_case       :					List[str]				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_distilbert_for_multiple_choice(*__snake_case				)







		def        lowercase       (    self				)      ->      List[Any]:


							'''simple docstring'''

							_snake_case       :					Dict				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_distilbert_for_token_classification(*__snake_case				)







		@slow
		def        lowercase       (    self				)      ->      Tuple:


							'''simple docstring'''

							for model_name in list(TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]				):
												_snake_case       :					Any				       =   TFDistilBertModel.from_pretrained(__snake_case				)
												self.assertIsNotNone(__snake_case				)






@require_tf
class        _a(    unittest.TestCase    ):







		@slow
		def        lowercase       (    self				)      ->      List[str]:


							'''simple docstring'''

							_snake_case       :					Any				       =   TFDistilBertModel.from_pretrained("distilbert-base-uncased"				)
							_snake_case       :					int				       =   tf.constant([[0, 1, 2, 3, 4, 5]]				)
							_snake_case       :					Dict				       =   model(__snake_case				)[0]

							_snake_case       :					str				       =   [1, 6, 7_6_8]
							self.assertEqual(output.shape ,						__snake_case				)

							_snake_case       :					Optional[Any]				       =   tf.constant(
							    [
							        [
							            [0.19_26_18_85, -0.13_73_29_55, 0.4_11_97_99],
							            [0.22_15_01_56, -0.07_42_26_61, 0.39_03_72_04],
							            [0.22_75_60_18, -0.0_89_64_14, 0.3_70_14_67],
							        ]
							    ]				)
							tf.debugging.assert_near(output[:, :3, :3] ,						__snake_case ,						atol=1E-4				)