


'''simple docstring'''

import unittest

import numpy as np

from transformers import AlbertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
							import jax.numpy as jnp

							from transformers.models.albert.modeling_flax_albert import (
							    FlaxAlbertForMaskedLM,
							    FlaxAlbertForMultipleChoice,
							    FlaxAlbertForPreTraining,
							    FlaxAlbertForQuestionAnswering,
							    FlaxAlbertForSequenceClassification,
							    FlaxAlbertForTokenClassification,
							    FlaxAlbertModel,
							)
class _lowerCamelCase	(						unittest.TestCase							):



		'''simple docstring'''







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







		def        __lowerCAmelCase		( self		:						str      )  ->			Optional[Any]:
			__magic_name__	:   Union[str, Any]					     =					ids_tensor([self.batch_size, self.seq_length]  ,					self.vocab_size      )

			__magic_name__	:   List[Any]					     =					None
			if self.use_attention_mask:
				__magic_name__	:   str					     =					random_attention_mask([self.batch_size, self.seq_length]      )

			__magic_name__	:   int					     =					None
			if self.use_token_type_ids:
				__magic_name__	:   Dict					     =					ids_tensor([self.batch_size, self.seq_length]  ,					self.type_vocab_size      )

			__magic_name__	:   Any					     =					AlbertConfig(
			    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  ,					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=_lowercase  ,					initializer_range=self.initializer_range  ,					)

			return config, input_ids, token_type_ids, attention_mask







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







@require_flax
class _lowerCamelCase	(						lowercase__		,					unittest.TestCase							):



		'''simple docstring'''







		A_     :      Optional[Any]				   =    (
		    (
		        FlaxAlbertModel,
		        FlaxAlbertForPreTraining,
		        FlaxAlbertForMaskedLM,
		        FlaxAlbertForMultipleChoice,
		        FlaxAlbertForQuestionAnswering,
		        FlaxAlbertForSequenceClassification,
		        FlaxAlbertForTokenClassification,
		        FlaxAlbertForQuestionAnswering,
		    )
		    if is_flax_available()
		    else ()
		)







		def        __lowerCAmelCase		( self		:						Dict      )  ->			Optional[int]:
			__magic_name__	:   List[str]					     =					FlaxAlbertModelTester(self      )







		@slow
		def        __lowerCAmelCase		( self		:						Union[str, Any]      )  ->			str:
			for model_class_name in self.all_model_classes:
				__magic_name__	:   Optional[int]					     =					model_class_name.from_pretrained('albert-base-v2'      )
				__magic_name__	:   Union[str, Any]					     =					model(np.ones((1, 1)      )      )
				self.assertIsNotNone(_lowercase      )







@require_flax
class _lowerCamelCase	(						unittest.TestCase							):



		'''simple docstring'''







		@slow
		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			List[str]:
			__magic_name__	:   List[str]					     =					FlaxAlbertModel.from_pretrained('albert-base-v2'      )
			__magic_name__	:   List[str]					     =					np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]      )
			__magic_name__	:   Union[str, Any]					     =					np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]      )
			__magic_name__	:   int					     =					model(_lowercase  ,					attention_mask=_lowercase      )[0]
			__magic_name__	:   str					     =					(1, 11, 768)
			self.assertEqual(output.shape  ,					_lowercase      )
			__magic_name__	:   Optional[int]					     =					np.array(
			    [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]      )

			self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]  ,					_lowercase  ,					atol=1E-4      )      )



'''simple docstring'''

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,
    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,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowerCAmelCase				:Tuple        =      logging.get_logger(__name__)
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		A_     :      int				   =    ["""pixel_values"""]







		def __init__( self		:						Any  ,					_A		:						bool = True  ,					_A		:						Optional[Dict[str, int]] = None  ,					_A		:						PILImageResampling = PILImageResampling.BILINEAR  ,					_A		:						bool = True  ,					_A		:						Dict[str, int] = None  ,					_A		:						bool = True  ,					_A		:						Union[int, float] = 1 / 255  ,					_A		:						bool = True  ,					_A		:						Optional[Union[float, List[float]]] = None  ,					_A		:						Optional[Union[float, List[float]]] = None  ,					**_A		:						Optional[Any]  ,					)  ->			None:
			super().__init__(**_A      )
			__magic_name__	:   List[str]					     =					size if size is not None else {'shortest_edge': 256}
			__magic_name__	:   str					     =					get_size_dict(_A  ,					default_to_square=_A      )
			__magic_name__	:   List[str]					     =					crop_size if crop_size is not None else {'height': 224, 'width': 224}
			__magic_name__	:   Optional[int]					     =					get_size_dict(_A      )
			__magic_name__	:   Union[str, Any]					     =					do_resize
			__magic_name__	:   List[Any]					     =					size
			__magic_name__	:   List[str]					     =					resample
			__magic_name__	:   Dict					     =					do_center_crop
			__magic_name__	:   List[str]					     =					crop_size
			__magic_name__	:   int					     =					do_rescale
			__magic_name__	:   Tuple					     =					rescale_factor
			__magic_name__	:   List[str]					     =					do_normalize
			__magic_name__	:   Union[str, Any]					     =					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
			__magic_name__	:   Dict					     =					image_std if image_std is not None else IMAGENET_STANDARD_STD







		def        __lowerCAmelCase		( self		:						Optional[Any]  ,					_A		:						np.ndarray  ,					_A		:						Dict[str, int]  ,					_A		:						PILImageResampling = PILImageResampling.BICUBIC  ,					_A		:						Optional[Union[str, ChannelDimension]] = None  ,					**_A		:						List[str]  ,					)  ->			np.ndarray:
			__magic_name__	:   Optional[Any]					     =					get_size_dict(_A  ,					default_to_square=_A      )
			if "shortest_edge" not in size:
				raise ValueError(F'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'      )
			__magic_name__	:   Dict					     =					get_resize_output_image_size(_A  ,					size=size['shortest_edge']  ,					default_to_square=_A      )
			return resize(_A  ,					size=_A  ,					resample=_A  ,					data_format=_A  ,					**_A      )







		def        __lowerCAmelCase		( self		:						Dict  ,					_A		:						np.ndarray  ,					_A		:						Dict[str, int]  ,					_A		:						Optional[Union[str, ChannelDimension]] = None  ,					**_A		:						Optional[int]  ,					)  ->			np.ndarray:
			__magic_name__	:   int					     =					get_size_dict(_A      )
			return center_crop(_A  ,					size=(size['height'], size['width'])  ,					data_format=_A  ,					**_A      )







		def        __lowerCAmelCase		( self		:						List[str]  ,					_A		:						np.ndarray  ,					_A		:						float  ,					_A		:						Optional[Union[str, ChannelDimension]] = None  ,					**_A		:						Tuple      )  ->			np.ndarray:
			return rescale(_A  ,					scale=_A  ,					data_format=_A  ,					**_A      )







		def        __lowerCAmelCase		( self		:						str  ,					_A		:						np.ndarray  ,					_A		:						Union[float, List[float]]  ,					_A		:						Union[float, List[float]]  ,					_A		:						Optional[Union[str, ChannelDimension]] = None  ,					**_A		:						int  ,					)  ->			np.ndarray:
			return normalize(_A  ,					mean=_A  ,					std=_A  ,					data_format=_A  ,					**_A      )







		def        __lowerCAmelCase		( self		:						List[str]  ,					_A		:						ImageInput  ,					_A		:						Optional[bool] = None  ,					_A		:						Dict[str, int] = None  ,					_A		:						PILImageResampling = None  ,					_A		:						bool = None  ,					_A		:						Dict[str, int] = None  ,					_A		:						Optional[bool] = None  ,					_A		:						Optional[float] = None  ,					_A		:						Optional[bool] = None  ,					_A		:						Optional[Union[float, List[float]]] = None  ,					_A		:						Optional[Union[float, List[float]]] = None  ,					_A		:						Optional[Union[str, TensorType]] = None  ,					_A		:						Union[str, ChannelDimension] = ChannelDimension.FIRST  ,					**_A		:						List[Any]  ,					)  ->			List[str]:
			__magic_name__	:   int					     =					do_resize if do_resize is not None else self.do_resize
			__magic_name__	:   Tuple					     =					size if size is not None else self.size
			__magic_name__	:   Optional[Any]					     =					get_size_dict(_A  ,					default_to_square=_A      )
			__magic_name__	:   Dict					     =					resample if resample is not None else self.resample
			__magic_name__	:   Optional[Any]					     =					do_center_crop if do_center_crop is not None else self.do_center_crop
			__magic_name__	:   Dict					     =					crop_size if crop_size is not None else self.crop_size
			__magic_name__	:   List[str]					     =					get_size_dict(_A      )
			__magic_name__	:   Union[str, Any]					     =					do_rescale if do_rescale is not None else self.do_rescale
			__magic_name__	:   str					     =					rescale_factor if rescale_factor is not None else self.rescale_factor
			__magic_name__	:   Any					     =					do_normalize if do_normalize is not None else self.do_normalize
			__magic_name__	:   Tuple					     =					image_mean if image_mean is not None else self.image_mean
			__magic_name__	:   Union[str, Any]					     =					image_std if image_std is not None else self.image_std

			__magic_name__	:   int					     =					make_list_of_images(_A      )

			if not valid_images(_A      ):
				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.'      )

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

			if do_resize:
				__magic_name__	:   Union[str, Any]					     =					[self.resize(image=_A  ,					size=_A  ,					resample=_A      ) for image in images]

			if do_center_crop:
				__magic_name__	:   Union[str, Any]					     =					[self.center_crop(image=_A  ,					size=_A      ) for image in images]

			if do_rescale:
				__magic_name__	:   List[Any]					     =					[self.rescale(image=_A  ,					scale=_A      ) for image in images]

			if do_normalize:
				__magic_name__	:   Optional[Any]					     =					[self.normalize(image=_A  ,					mean=_A  ,					std=_A      ) for image in images]

			__magic_name__	:   Union[str, Any]					     =					[to_channel_dimension_format(_A  ,					_A      ) for image in images]

			__magic_name__	:   List[str]					     =					{'pixel_values': images}
			return BatchFeature(data=_A  ,					tensor_type=_A      )