






"""simple docstring"""





import warnings

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


__lowerCamelCase							=  logging.get_logger(__name__)

__lowerCamelCase							=  {
    'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/config.json',
    'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/config.json',
}



class       __A		(   SCREAMING_SNAKE_CASE_			):
					UpperCAmelCase__								=				"xlnet"
					UpperCAmelCase__								=				["mems"]
					UpperCAmelCase__								=				{
					    "n_token": "vocab_size",  # Backward compatibility
					    "hidden_size": "d_model",
					    "num_attention_heads": "n_head",
					    "num_hidden_layers": "n_layer",
					}

					def __init__(			self  :      Optional[Any]     ,		__snake_case  :      int=3_2_0_0_0     ,		__snake_case  :      Tuple=1_0_2_4     ,		__snake_case  :      List[str]=2_4     ,		__snake_case  :      Dict=1_6     ,		__snake_case  :      Tuple=4_0_9_6     ,		__snake_case  :      str="gelu"     ,		__snake_case  :      Dict=True     ,		__snake_case  :      Optional[Any]="bi"     ,		__snake_case  :      Any=0.02     ,		__snake_case  :      Tuple=1E-12     ,		__snake_case  :      List[str]=0.1     ,		__snake_case  :      Any=5_1_2     ,		__snake_case  :      Optional[int]=None     ,		__snake_case  :      Any=True     ,		__snake_case  :      List[str]=False     ,		__snake_case  :      Dict=False     ,		__snake_case  :      List[Any]=-1     ,		__snake_case  :      List[Any]=False     ,		__snake_case  :      Tuple="last"     ,		__snake_case  :      Optional[Any]=True     ,		__snake_case  :      List[str]="tanh"     ,		__snake_case  :      Any=0.1     ,		__snake_case  :      str=5     ,		__snake_case  :      Optional[Any]=5     ,		__snake_case  :      List[str]=5     ,		__snake_case  :      str=1     ,		__snake_case  :      Dict=2     ,		**__snake_case  :      Dict     ,		)			->							Optional[int]:
											__magic_name__:	Dict							=       vocab_size
											__magic_name__:	List[Any]							=       d_model
											__magic_name__:	int							=       n_layer
											__magic_name__:	List[Any]							=       n_head
											if d_model % n_head != 0:
																	raise ValueError(F'\'d_model % n_head\' ({d_model % n_head}) should be equal to 0'					)
											if "d_head" in kwargs:
																	if kwargs["d_head"] != d_model // n_head:
																							raise ValueError(
																							    F'`d_head` ({kwargs["d_head"]}) should be equal to `d_model // n_head` ({d_model // n_head})'					)
											__magic_name__:	str							=       d_model // n_head
											__magic_name__:	Optional[Any]							=       ff_activation
											__magic_name__:	Tuple							=       d_inner
											__magic_name__:	int							=       untie_r
											__magic_name__:	Optional[Any]							=       attn_type

											__magic_name__:	str							=       initializer_range
											__magic_name__:	List[Any]							=       layer_norm_eps

											__magic_name__:	Union[str, Any]							=       dropout
											__magic_name__:	List[Any]							=       mem_len
											__magic_name__:	str							=       reuse_len
											__magic_name__:	int							=       bi_data
											__magic_name__:	Optional[int]							=       clamp_len
											__magic_name__:	str							=       same_length

											__magic_name__:	Tuple							=       summary_type
											__magic_name__:	List[Any]							=       summary_use_proj
											__magic_name__:	Union[str, Any]							=       summary_activation
											__magic_name__:	Tuple							=       summary_last_dropout
											__magic_name__:	Union[str, Any]							=       start_n_top
											__magic_name__:	Optional[int]							=       end_n_top

											__magic_name__:	Tuple							=       bos_token_id
											__magic_name__:	int							=       pad_token_id
											__magic_name__:	List[Any]							=       eos_token_id

											if "use_cache" in kwargs:
																	warnings.warn(
																	    """The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`"""
																	    """ instead."""     ,		__snake_case     ,		)
																	__magic_name__:	int							=       kwargs["""use_cache"""]

											__magic_name__:	str							=       use_mems_eval
											__magic_name__:	List[str]							=       use_mems_train
											super().__init__(pad_token_id=__snake_case     ,		bos_token_id=__snake_case     ,		eos_token_id=__snake_case     ,		**__snake_case					)

					@property
					def   lowerCamelCase__   (			self  :      Dict					)			->							Any:
											logger.info(F'The model {self.model_type} is one of the few models that has no sequence length limit.'					)
											return -1






					@max_position_embeddings.setter
					def   lowerCamelCase__   (			self  :      Tuple     ,		__snake_case  :      Optional[Any]					)			->							str:
											# Message copied from Transformer-XL documentation
											raise NotImplementedError(
											    F'The model {self.model_type} is one of the few models that has no sequence length limit.'					)











"""simple docstring"""





from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


__lowerCamelCase							=  logging.get_logger(__name__)



class       __A		(   SCREAMING_SNAKE_CASE_			):

					def __init__(			self  :      Union[str, Any]     ,		__snake_case  :      int     ,		__snake_case  :      int     ,		__snake_case  :      float     ,		**__snake_case  :      Optional[Any]					)			->							str:
											__magic_name__:	Optional[Any]							=       feature_size
											__magic_name__:	List[Any]							=       sampling_rate
											__magic_name__:	Tuple							=       padding_value

											__magic_name__:	int							=       kwargs.pop("""padding_side"""     ,		"""right"""					)
											__magic_name__:	Optional[Any]							=       kwargs.pop("""return_attention_mask"""     ,		__snake_case					)

											super().__init__(**__snake_case					)

					def   lowerCamelCase__   (			self  :      Union[str, Any]     ,		__snake_case  :      Union[
					        BatchFeature,
					        List[BatchFeature],
					        Dict[str, BatchFeature],
					        Dict[str, List[BatchFeature]],
					        List[Dict[str, BatchFeature]],
					    ]     ,		__snake_case  :      Union[bool, str, PaddingStrategy] = True     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      bool = False     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[bool] = None     ,		__snake_case  :      Optional[Union[str, TensorType]] = None     ,		)			->							BatchFeature:
											# If we have a list of dicts, let's convert it in a dict of lists
											# We do this to allow using this method as a collate_fn function in PyTorch Dataloader
											if isinstance(__snake_case     ,		(list, tuple)					) and isinstance(processed_features[0]     ,		(dict, BatchFeature)					):
																	__magic_name__:	Union[str, Any]							=       {
																	    key: [example[key] for example in processed_features] for key in processed_features[0].keys()
																	}

											# The model's main input name, usually `input_values`, has be passed for padding
											if self.model_input_names[0] not in processed_features:
																	raise ValueError(
																	    """You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`"""
																	    F' to this method that includes {self.model_input_names[0]}, but you provided'
																	    F' {list(processed_features.keys()					)}'					)

											__magic_name__:	Any							=       processed_features[self.model_input_names[0]]
											__magic_name__:	Tuple							=       (
											    return_attention_mask if return_attention_mask is not None else self.return_attention_mask
											)

											if len(__snake_case					) == 0:
																	if return_attention_mask:
																							__magic_name__:	Optional[Any]							=       []
																	return processed_features

											# If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
											# and rebuild them afterwards if no return_tensors is specified
											# Note that we lose the specific device the tensor may be on for PyTorch

											__magic_name__:	Tuple							=       required_input[0]
											if isinstance(__snake_case     ,		(list, tuple)					):
																	# first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
																	__magic_name__:	str							=       0
																	while len(required_input[index]					) == 0:
																							index += 1
																	if index < len(__snake_case					):
																							__magic_name__:	Optional[int]							=       required_input[index][0]

											if return_tensors is None:
																	if is_tf_tensor(__snake_case					):
																							__magic_name__:	List[str]							=       """tf"""
																	elif is_torch_tensor(__snake_case					):
																							__magic_name__:	Any							=       """pt"""
																	elif isinstance(__snake_case     ,		(int, float, list, tuple, np.ndarray)					):
																							__magic_name__:	int							=       """np"""
																	else:
																							raise ValueError(
																							    F'type of {first_element} unknown: {type(__snake_case					)}. '
																							    """Should be one of a python, numpy, pytorch or tensorflow object."""					)

											for key, value in processed_features.items():
																	if isinstance(value[0]     ,		(int, float)					):
																							__magic_name__:	List[str]							=       to_numpy(__snake_case					)
																	else:
																							__magic_name__:	Any							=       [to_numpy(__snake_case					) for v in value]

        # Convert padding_strategy in PaddingStrategy
											__magic_name__:	str							=       self._get_padding_strategies(padding=__snake_case     ,		max_length=__snake_case					)

											__magic_name__:	str							=       processed_features[self.model_input_names[0]]

											__magic_name__:	str							=       len(__snake_case					)
											if not all(len(__snake_case					) == batch_size for v in processed_features.values()					):
																	raise ValueError("""Some items in the output dictionary have a different batch size than others."""					)

											__magic_name__:	List[Any]							=       []
											for i in range(__snake_case					):
																	__magic_name__:	List[Any]							=       {k: v[i] for k, v in processed_features.items()}
																	# truncation
																	__magic_name__:	List[Any]							=       self._truncate(
																	    __snake_case     ,		max_length=__snake_case     ,		pad_to_multiple_of=__snake_case     ,		truncation=__snake_case     ,		)
																	truncated_inputs.append(__snake_case					)

											if padding_strategy == PaddingStrategy.LONGEST:
																	# make sure that `max_length` cannot be longer than the longest truncated length
																	__magic_name__:	Union[str, Any]							=       max(len(input_slice[self.model_input_names[0]]					) for input_slice in truncated_inputs					)
																	__magic_name__:	Union[str, Any]							=       PaddingStrategy.MAX_LENGTH

											__magic_name__:	List[str]							=       {}
											for i in range(__snake_case					):
																	# padding
																	__magic_name__:	str							=       self._pad(
																	    truncated_inputs[i]     ,		max_length=__snake_case     ,		padding_strategy=__snake_case     ,		pad_to_multiple_of=__snake_case     ,		return_attention_mask=__snake_case     ,		)

																	for key, value in outputs.items():
																							if key not in batch_outputs:
																													__magic_name__:	Optional[Any]							=       []
																							if value.dtype is np.dtype(np.floataa					):
																													__magic_name__:	Any							=       value.astype(np.floataa					)
																							batch_outputs[key].append(__snake_case					)

											return BatchFeature(__snake_case     ,		tensor_type=__snake_case					)

					def   lowerCamelCase__   (			self  :      Tuple     ,		__snake_case  :      Union[Dict[str, np.ndarray], BatchFeature]     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      PaddingStrategy = PaddingStrategy.DO_NOT_PAD     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[bool] = None     ,		)			->							dict:
											__magic_name__:	List[str]							=       processed_features[self.model_input_names[0]]

											if padding_strategy == PaddingStrategy.LONGEST:
																	__magic_name__:	List[Any]							=       len(__snake_case					)

											if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
																	__magic_name__:	List[str]							=       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

											__magic_name__:	str							=       padding_strategy != PaddingStrategy.DO_NOT_PAD and len(__snake_case					) < max_length

											if return_attention_mask and "attention_mask" not in processed_features:
																	__magic_name__:	int							=       np.ones(len(__snake_case					)     ,		dtype=np.intaa					)

											if needs_to_be_padded:
																	__magic_name__:	str							=       max_length - len(__snake_case					)
																	if self.padding_side == "right":
																							if return_attention_mask:
																													__magic_name__:	List[Any]							=       np.pad(
																													    processed_features["""attention_mask"""]     ,		(0, difference)					)
																							__magic_name__:	Union[str, Any]							=       ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
																							__magic_name__:	int							=       np.pad(
																							    __snake_case     ,		__snake_case     ,		"""constant"""     ,		constant_values=self.padding_value					)
																	elif self.padding_side == "left":
																							if return_attention_mask:
																													__magic_name__:	Dict							=       np.pad(
																													    processed_features["""attention_mask"""]     ,		(difference, 0)					)
																							__magic_name__:	Optional[Any]							=       ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
																							__magic_name__:	int							=       np.pad(
																							    __snake_case     ,		__snake_case     ,		"""constant"""     ,		constant_values=self.padding_value					)
																	else:
																							raise ValueError("""Invalid padding strategy:""" + str(self.padding_side					)					)

											return processed_features

					def   lowerCamelCase__   (			self  :      Optional[Any]     ,		__snake_case  :      Union[Dict[str, np.ndarray], BatchFeature]     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[int] = None     ,		__snake_case  :      Optional[bool] = None     ,		)			->							int:
											if not truncation:
																	return processed_features
											elif truncation and max_length is None:
																	raise ValueError("""When setting ``truncation=True``, make sure that ``max_length`` is defined."""					)

											__magic_name__:	Dict							=       processed_features[self.model_input_names[0]]

											# find `max_length` that fits `pad_to_multiple_of`
											if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
																	__magic_name__:	Optional[Any]							=       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

											__magic_name__:	Tuple							=       len(__snake_case					) > max_length

											if needs_to_be_truncated:
																	__magic_name__:	Any							=       processed_features[self.model_input_names[0]][:max_length]
																	if "attention_mask" in processed_features:
																							__magic_name__:	List[Any]							=       processed_features["""attention_mask"""][:max_length]

											return processed_features






					def   lowerCamelCase__   (			self  :      List[Any]     ,		__snake_case  :      int=False     ,		__snake_case  :      Tuple=None					)			->							Optional[Any]:

											# Get padding strategy
											if padding is not False:
																	if padding is True:
																							__magic_name__:	Optional[Any]							=       PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
																	elif not isinstance(__snake_case     ,		__snake_case					):
																							__magic_name__:	Tuple							=       PaddingStrategy(__snake_case					)
																	elif isinstance(__snake_case     ,		__snake_case					):
																							__magic_name__:	Dict							=       padding
											else:
																	__magic_name__:	int							=       PaddingStrategy.DO_NOT_PAD

											# Set max length if needed
											if max_length is None:
																	if padding_strategy == PaddingStrategy.MAX_LENGTH:
																							raise ValueError(
																							    F'When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined'					)

        # Test if we have a padding value
											if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
																	raise ValueError(
																	    """Asking to pad but the feature_extractor does not have a padding value. Please select a value to use"""
																	    """ as `padding_value`. For example: `feature_extractor.padding_value = 0.0`."""					)

											return padding_strategy



