





'''simple docstring'''




from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


__UpperCAmelCase            =       logging.get_logger(__name__)



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		if isinstance(lowerCamelCase_			,			np.ndarray	):
				return list(tensor.shape	)

		SCREAMING_SNAKE_CASE :				int		=			tf.shape(lowerCamelCase_	)

		if tensor.shape == tf.TensorShape(lowerCamelCase_	):
				return dynamic

		SCREAMING_SNAKE_CASE :				str		=			tensor.shape.as_list()

		return [dynamic[i] if s is None else s for i, s in enumerate(lowerCamelCase_	)]



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_ = None			,			lowerCamelCase_ = None	):


		"""simple docstring"""



		return tf.nn.softmax(logits=logits + 1E-9			,			axis=lowerCamelCase_			,			name=lowerCamelCase_	)



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_=1E-5			,			lowerCamelCase_=-1	):


		"""simple docstring"""



		if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(lowerCamelCase_			,			lowerCamelCase_	):
				raise NotImplementedError("""Only 1D weight and bias tensors are supported for now, with only a single axis."""	)

		# Get mean and variance on the axis to be normalized
		SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			tf.nn.moments(lowerCamelCase_			,			axes=[axis]			,			keepdims=lowerCamelCase_	)

		if axis != -1:
				# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
				# on every dimension except axis
				SCREAMING_SNAKE_CASE :				int		=			[1] * inputs.shape.rank
				SCREAMING_SNAKE_CASE :				Optional[int]		=			shape_list(lowerCamelCase_	)[axis]
				SCREAMING_SNAKE_CASE :				Any		=			tf.reshape(lowerCamelCase_			,			lowerCamelCase_	)
				SCREAMING_SNAKE_CASE :				Any		=			tf.reshape(lowerCamelCase_			,			lowerCamelCase_	)

		# Compute layer normalization using the batch_normalization
		# function.
		SCREAMING_SNAKE_CASE :				Any		=			tf.nn.batch_normalization(
		    lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_			,			offset=lowerCamelCase_			,			scale=lowerCamelCase_			,			variance_epsilon=lowerCamelCase_			,			)
		return outputs



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_=0			,			lowerCamelCase_=-1	):


		"""simple docstring"""



		if end_dim < 0:
				end_dim += input.shape.rank
		if start_dim < 0:
				start_dim += input.shape.rank

		if start_dim == end_dim:
				return input

		SCREAMING_SNAKE_CASE :				Dict		=			tf.shape(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Tuple		=			tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]	)
		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]			,			axis=0	)
		return tf.reshape(lowerCamelCase_			,			lowerCamelCase_	)



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		if not isinstance(lowerCamelCase_			,			tf.Tensor	):
				SCREAMING_SNAKE_CASE :				str		=			tf.convert_to_tensor(lowerCamelCase_	)  # Catches stray NumPy inputs
		if encoder_attention_mask.shape.rank == 3:
				SCREAMING_SNAKE_CASE :				Union[str, Any]		=			encoder_attention_mask[:, None, :, :]
		if encoder_attention_mask.shape.rank == 2:
				SCREAMING_SNAKE_CASE :				Tuple		=			encoder_attention_mask[:, None, None, :]
		# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
		# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
		# /transformer/transformer_layers.py#L270
		# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
		# encoder_extended_attention_mask.transpose(-1, -2))
		SCREAMING_SNAKE_CASE :				str		=			(
		    tf.cast(1			,			encoder_attention_mask.dtype	) - encoder_extended_attention_mask
		) * encoder_extended_attention_mask.dtype.min

		return encoder_extended_attention_mask



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_ = "input_ids"	):


		"""simple docstring"""



		tf.debugging.assert_less(
		    lowerCamelCase_			,			tf.cast(lowerCamelCase_			,			dtype=tensor.dtype	)			,			message=(
		        f'''The maximum value of {tensor_name} ({tf.math.reduce_max(lowerCamelCase_	)}) must be smaller than the embedding '''
		        f'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.'''
		    )			,			)



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				Tuple		=			6_45_12
		# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
		# because in that case even chunking the array would not make the saving
		# possible.
		SCREAMING_SNAKE_CASE :				List[str]		=			[x for x in data if len(lowerCamelCase_	) > HDF5_OBJECT_HEADER_LIMIT]

		# Expecting this to never be true.
		if bad_attributes:
				raise RuntimeError(
				    """The following attributes cannot be saved to HDF5 file because """
				    f'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} '''
				    f'''bytes: {bad_attributes}'''	)

		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			np.asarray(lowerCamelCase_	)

		SCREAMING_SNAKE_CASE :				Tuple		=			1
		SCREAMING_SNAKE_CASE :				int		=			np.array_split(lowerCamelCase_			,			lowerCamelCase_	)

		# This will never loop forever thanks to the test above.
		while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data	):
				num_chunks += 1
				SCREAMING_SNAKE_CASE :				Optional[Any]		=			np.array_split(lowerCamelCase_			,			lowerCamelCase_	)

		if num_chunks > 1:
				for chunk_id, chunk_data in enumerate(lowerCamelCase_	):
						SCREAMING_SNAKE_CASE :				Optional[Any]		=			chunk_data
		else:
				SCREAMING_SNAKE_CASE :				Union[str, Any]		=			data



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		if name in group.attrs:
				SCREAMING_SNAKE_CASE :				Dict		=			[n.decode("""utf8"""	) if hasattr(lowerCamelCase_			,			"""decode"""	) else n for n in group.attrs[name]]
		else:
				SCREAMING_SNAKE_CASE :				Tuple		=			[]
				SCREAMING_SNAKE_CASE :				List[Any]		=			0
				while "%s%d" % (name, chunk_id) in group.attrs:
						data.extend(
						    [n.decode("""utf8"""	) if hasattr(lowerCamelCase_			,			"""decode"""	) else n for n in group.attrs["""%s%d""" % (name, chunk_id)]]	)
						chunk_id += 1
		return data



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		def _expand_single_ad_tensor(lowerCamelCase_	):
				if isinstance(lowerCamelCase_			,			tf.Tensor	) and t.shape.rank == 1:
						return tf.expand_dims(lowerCamelCase_			,			axis=-1	)
				return t

		return tf.nest.map_structure(_expand_single_ad_tensor			,			lowerCamelCase_	)










'''simple docstring'''




from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCAmelCase            =       logging.get_logger(__name__)

__UpperCAmelCase            =       {
    """naver-clova-ix/donut-base""": """https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json""",
    # See all Donut models at https://huggingface.co/models?filter=donut-swin
}




class      UpperCamelCase__					(					lowercase_			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	'''donut-swin'''

					SCREAMING_SNAKE_CASE__				=	{
					    '''num_attention_heads''': '''num_heads''',
					    '''num_hidden_layers''': '''num_layers''',
					}


					def __init__(						self				:			str      ,						lowerCamelCase_				:			Union[str, Any]=2_24      ,						lowerCamelCase_				:			Union[str, Any]=4      ,						lowerCamelCase_				:			Optional[Any]=3      ,						lowerCamelCase_				:			Dict=96      ,						lowerCamelCase_				:			int=[2, 2, 6, 2]      ,						lowerCamelCase_				:			Optional[Any]=[3, 6, 12, 24]      ,						lowerCamelCase_				:			List[str]=7      ,						lowerCamelCase_				:			List[str]=4.0      ,						lowerCamelCase_				:			Optional[Any]=True      ,						lowerCamelCase_				:			List[str]=0.0      ,						lowerCamelCase_				:			Dict=0.0      ,						lowerCamelCase_				:			Dict=0.1      ,						lowerCamelCase_				:			Union[str, Any]="gelu"      ,						lowerCamelCase_				:			List[str]=False      ,						lowerCamelCase_				:			Optional[int]=0.02      ,						lowerCamelCase_				:			Any=1e-5      ,						**lowerCamelCase_				:			Union[str, Any]      ,						):

							'''simple docstring'''



							super().__init__(**lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				int		=			image_size
							SCREAMING_SNAKE_CASE :				Dict		=			patch_size
							SCREAMING_SNAKE_CASE :				str		=			num_channels
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			embed_dim
							SCREAMING_SNAKE_CASE :				Optional[int]		=			depths
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			len(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Optional[int]		=			num_heads
							SCREAMING_SNAKE_CASE :				Optional[int]		=			window_size
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			mlp_ratio
							SCREAMING_SNAKE_CASE :				Dict		=			qkv_bias
							SCREAMING_SNAKE_CASE :				Optional[int]		=			hidden_dropout_prob
							SCREAMING_SNAKE_CASE :				Tuple		=			attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE :				Dict		=			drop_path_rate
							SCREAMING_SNAKE_CASE :				List[str]		=			hidden_act
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			use_absolute_embeddings
							SCREAMING_SNAKE_CASE :				Tuple		=			layer_norm_eps
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			initializer_range
							# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
							# this indicates the channel dimension after the last stage of the model
							SCREAMING_SNAKE_CASE :				str		=			int(embed_dim * 2 ** (len(lowerCamelCase_						) - 1)						)



