
'''simple docstring'''







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


_snake_case				:   int     =				logging.get_logger(__name__)

_snake_case				:   Optional[Any]     =				{
    """tanreinama/GPTSAN-2.8B-spout_is_uniform""": (
        """https://huggingface.co/tanreinama/GPTSAN-2.8B-spout_is_uniform/resolve/main/config.json"""
    ),
}


class 			lowerCAmelCase (				__A			):
		a							:					Optional[int]       =					"""gptsan-japanese"""
		a							:					Optional[int]       =					[
		    """past_key_values""",
		]
		a							:					int       =					{
		    """hidden_size""": """d_model""",
		    """num_attention_heads""": """num_heads""",
		    """num_hidden_layers""": """num_layers""",
		}




		def __init__(				self					,						UpperCamelCase=36_000					,						UpperCamelCase=1_280					,						UpperCamelCase=1_024					,						UpperCamelCase=8_192					,						UpperCamelCase=4_096					,						UpperCamelCase=128					,						UpperCamelCase=10					,						UpperCamelCase=0					,						UpperCamelCase=16					,						UpperCamelCase=16					,						UpperCamelCase=128					,						UpperCamelCase=0.0					,						UpperCamelCase=1e-5					,						UpperCamelCase=False					,						UpperCamelCase=0.0					,						UpperCamelCase="float32"					,						UpperCamelCase=False					,						UpperCamelCase=False					,						UpperCamelCase=False					,						UpperCamelCase=0.0_02					,						UpperCamelCase=False					,						UpperCamelCase=True					,						UpperCamelCase=35_998					,						UpperCamelCase=35_995					,						UpperCamelCase=35_999					,						**UpperCamelCase					,						):
								_SCREAMING_SNAKE_CASE				= vocab_size
								_SCREAMING_SNAKE_CASE				= max_position_embeddings
								_SCREAMING_SNAKE_CASE				= d_model
								_SCREAMING_SNAKE_CASE				= d_ff
								_SCREAMING_SNAKE_CASE				= d_ext
								_SCREAMING_SNAKE_CASE				= d_spout
								_SCREAMING_SNAKE_CASE				= num_switch_layers
								_SCREAMING_SNAKE_CASE				= num_ext_layers
								_SCREAMING_SNAKE_CASE				= num_switch_layers + num_ext_layers
								_SCREAMING_SNAKE_CASE				= num_heads
								_SCREAMING_SNAKE_CASE				= num_experts
								_SCREAMING_SNAKE_CASE				= expert_capacity
								_SCREAMING_SNAKE_CASE				= dropout_rate
								_SCREAMING_SNAKE_CASE				= layer_norm_epsilon
								_SCREAMING_SNAKE_CASE				= router_bias
								_SCREAMING_SNAKE_CASE				= router_jitter_noise
								_SCREAMING_SNAKE_CASE				= router_dtype
								_SCREAMING_SNAKE_CASE				= router_ignore_padding_tokens
								_SCREAMING_SNAKE_CASE				= output_hidden_states
								_SCREAMING_SNAKE_CASE				= output_attentions
								_SCREAMING_SNAKE_CASE				= initializer_factor
								_SCREAMING_SNAKE_CASE				= output_router_logits
								_SCREAMING_SNAKE_CASE				= use_cache

								super().__init__(
								    separator_token_id=UpperCamelCase__					,						pad_token_id=UpperCamelCase__					,						eos_token_id=UpperCamelCase__					,						**UpperCamelCase__					,						)

'''simple docstring'''







import numpy as np
import torch
from torch.utils.data import Dataset, IterableDataset

from ..utils.generic import ModelOutput


class 			lowerCAmelCase (				__UpperCAmelCase			):




		def __init__(				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= dataset
								_SCREAMING_SNAKE_CASE				= process
								_SCREAMING_SNAKE_CASE				= params




		def __len__(				self      ):
								return len(self.dataset      )




		def __getitem__(				self					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= self.dataset[i]
								_SCREAMING_SNAKE_CASE				= self.process(UpperCamelCase					,						**self.params      )
								return processed


class 			lowerCAmelCase (				__UpperCAmelCase			):




		def __init__(				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase=None      ):
								_SCREAMING_SNAKE_CASE				= loader
								_SCREAMING_SNAKE_CASE				= infer
								_SCREAMING_SNAKE_CASE				= params
								if loader_batch_size == 1:
														# Let's spare some time by deactivating altogether
														_SCREAMING_SNAKE_CASE				= None
								_SCREAMING_SNAKE_CASE				= loader_batch_size

								# Internal bookkeeping
								_SCREAMING_SNAKE_CASE				= None
								_SCREAMING_SNAKE_CASE				= None




		def __len__(				self      ):
								return len(self.loader      )




		def __iter__(				self      ):
								_SCREAMING_SNAKE_CASE				= iter(self.loader      )
								return self




		def     lowercase       (				self      ):
								if isinstance(self._loader_batch_data					,						torch.Tensor      ):
														# Batch data is simple tensor, just fetch the slice
														_SCREAMING_SNAKE_CASE				= self._loader_batch_data[self._loader_batch_index]
								else:
														# Batch data is assumed to be BaseModelOutput (or dict)
														_SCREAMING_SNAKE_CASE				= {}
														for k, element in self._loader_batch_data.items():
																				if isinstance(UpperCamelCase					,						UpperCamelCase      ):
																										# Convert ModelOutput to tuple first
																										_SCREAMING_SNAKE_CASE				= element.to_tuple()
																										if isinstance(element[0]					,						torch.Tensor      ):
																																_SCREAMING_SNAKE_CASE				= tuple(el[self._loader_batch_index].unsqueeze(0      ) for el in element      )
																										elif isinstance(element[0]					,						np.ndarray      ):
																																_SCREAMING_SNAKE_CASE				= tuple(np.expand_dims(el[self._loader_batch_index]					,						0      ) for el in element      )
																										continue
																				if k in {"hidden_states", "past_key_values", "attentions"} and isinstance(UpperCamelCase					,						UpperCamelCase      ):
																										# Those are stored as lists of tensors so need specific unbatching.
																										if isinstance(element[0]					,						torch.Tensor      ):
																																_SCREAMING_SNAKE_CASE				= tuple(el[self._loader_batch_index].unsqueeze(0      ) for el in element      )
																										elif isinstance(element[0]					,						np.ndarray      ):
																																_SCREAMING_SNAKE_CASE				= tuple(np.expand_dims(el[self._loader_batch_index]					,						0      ) for el in element      )
																										continue
																				if element is None:
																										# This can happen for optional data that get passed around
																										_SCREAMING_SNAKE_CASE				= None
																				elif isinstance(element[self._loader_batch_index]					,						torch.Tensor      ):
																										# Take correct batch data, but make it looked like batch_size=1
																										# For compatibility with other methods within transformers

																										_SCREAMING_SNAKE_CASE				= element[self._loader_batch_index].unsqueeze(0      )
																				elif isinstance(element[self._loader_batch_index]					,						np.ndarray      ):
																										# Take correct batch data, but make it looked like batch_size=1
																										# For compatibility with other methods within transformers
																										_SCREAMING_SNAKE_CASE				= np.expand_dims(element[self._loader_batch_index]					,						0      )
																				else:
																										# This is typically a list, so no need to `unsqueeze`.
																										_SCREAMING_SNAKE_CASE				= element[self._loader_batch_index]
            # Recreate the element by reusing the original class to make it look
            # batch_size=1
														_SCREAMING_SNAKE_CASE				= self._loader_batch_data.__class__(UpperCamelCase      )
								self._loader_batch_index += 1
								return result




		def     lowercase       (				self      ):
								if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size:
														# We are currently unrolling a batch so we just need to return
														# the current item within a batch
														return self.loader_batch_item()

								# We're out of items within a batch
								_SCREAMING_SNAKE_CASE				= next(self.iterator      )
								_SCREAMING_SNAKE_CASE				= self.infer(UpperCamelCase					,						**self.params      )
								# We now have a batch of "inferred things".
								if self.loader_batch_size is not None:
														# Try to infer the size of the batch
														if isinstance(UpperCamelCase					,						torch.Tensor      ):
																				_SCREAMING_SNAKE_CASE				= processed
														else:
																				_SCREAMING_SNAKE_CASE				= list(processed.keys()      )[0]
																				_SCREAMING_SNAKE_CASE				= processed[key]
														if isinstance(UpperCamelCase					,						UpperCamelCase      ):
																				_SCREAMING_SNAKE_CASE				= len(UpperCamelCase      )
														else:
																				_SCREAMING_SNAKE_CASE				= first_tensor.shape[0]
														if 0 < observed_batch_size < self.loader_batch_size:
																				# could be last batch so we can't unroll as many
																				# elements.
																				_SCREAMING_SNAKE_CASE				= observed_batch_size
														# Setting internal index to unwrap the batch
														_SCREAMING_SNAKE_CASE				= processed
														_SCREAMING_SNAKE_CASE				= 0
														return self.loader_batch_item()
								else:
														# We're not unrolling batches
														return processed


class 			lowerCAmelCase (				__UpperCAmelCase			):




		def __init__(				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase=None      ):
								super().__init__(UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      )




		def __iter__(				self      ):
								_SCREAMING_SNAKE_CASE				= iter(self.loader      )
								_SCREAMING_SNAKE_CASE				= None
								return self




		def     lowercase       (				self      ):
								if self.subiterator is None:
														_SCREAMING_SNAKE_CASE				= self.infer(next(self.iterator      )					,						**self.params      )
								try:
														# Try to return next item
														_SCREAMING_SNAKE_CASE				= next(self.subiterator      )
								except StopIteration:
														# When a preprocess iterator ends, we can start lookig at the next item
														# ChunkIterator will keep feeding until ALL elements of iterator
														# all have created their subiterator and have been iterating against.
														#
														# Another way to look at it, is we're basically flattening lists of lists
														# into a single list, but with generators
														_SCREAMING_SNAKE_CASE				= self.infer(next(self.iterator      )					,						**self.params      )
														_SCREAMING_SNAKE_CASE				= next(self.subiterator      )
								return processed


class 			lowerCAmelCase (				__UpperCAmelCase			):




		def __iter__(				self      ):
								_SCREAMING_SNAKE_CASE				= iter(self.loader      )
								return self




		def     lowercase       (				self      ):
								# Extremely similar to PipelineIterator in its unpacking mechanism
								# BUT, we have an extra required item which is the presence of `is_last`
								# That is because everything is flattened by `PipelineChunkIterator` we
								# need to keep track of how to regroup here in the original `process`
								# boundaries so that `process` and `postprocess` see the same data.

								# This iterator accumulates items (possibly while unbatching) until it
								# its a `is_last` and then just passes it on to the caller.
								_SCREAMING_SNAKE_CASE				= False
								_SCREAMING_SNAKE_CASE				= []
								if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size:
														while self._loader_batch_index < self.loader_batch_size:
																				_SCREAMING_SNAKE_CASE				= self.loader_batch_item()
																				_SCREAMING_SNAKE_CASE				= item.pop("is_last"      )
																				accumulator.append(UpperCamelCase      )
																				if is_last:
																										return accumulator

								while not is_last:
														_SCREAMING_SNAKE_CASE				= self.infer(next(self.iterator      )					,						**self.params      )
														if self.loader_batch_size is not None:
																				if isinstance(UpperCamelCase					,						torch.Tensor      ):
																										_SCREAMING_SNAKE_CASE				= processed
																				else:
																										_SCREAMING_SNAKE_CASE				= list(processed.keys()      )[0]
																										_SCREAMING_SNAKE_CASE				= processed[key]
																				if isinstance(UpperCamelCase					,						UpperCamelCase      ):
																										_SCREAMING_SNAKE_CASE				= len(UpperCamelCase      )
																				else:
																										_SCREAMING_SNAKE_CASE				= first_tensor.shape[0]
																				if 0 < observed_batch_size < self.loader_batch_size:
																										# could be last batch so we can't unroll as many
																										# elements.
																										_SCREAMING_SNAKE_CASE				= observed_batch_size
																				_SCREAMING_SNAKE_CASE				= processed
																				_SCREAMING_SNAKE_CASE				= 0
																				while self._loader_batch_index < self.loader_batch_size:
																										_SCREAMING_SNAKE_CASE				= self.loader_batch_item()
																										_SCREAMING_SNAKE_CASE				= item.pop("is_last"      )
																										accumulator.append(UpperCamelCase      )
																										if is_last:
																																return accumulator
														else:
																				_SCREAMING_SNAKE_CASE				= processed
																				_SCREAMING_SNAKE_CASE				= item.pop("is_last"      )
																				accumulator.append(UpperCamelCase      )
								return accumulator


class 			lowerCAmelCase (				__UpperCAmelCase			):




		def __init__(				self					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= dataset
								_SCREAMING_SNAKE_CASE				= key




		def __len__(				self      ):
								return len(self.dataset      )




		def __getitem__(				self					,						UpperCamelCase      ):
								return self.dataset[i][self.key]


class 			lowerCAmelCase (				__UpperCAmelCase			):




		def __init__(				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= dataset
								_SCREAMING_SNAKE_CASE				= keya
								_SCREAMING_SNAKE_CASE				= keya




		def __len__(				self      ):
								return len(self.dataset      )




		def __getitem__(				self					,						UpperCamelCase      ):
								return {"text": self.dataset[i][self.keya], "text_pair": self.dataset[i][self.keya]}