



from typing import Dict, List, Optional, Tuple, 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, is_torch_available, is_torch_tensor, logging


if is_torch_available():
 import torch


__snake_case						:Optional[int]						=					logging.get_logger(__name__)

class    _A	(     __UpperCAmelCase   ):
       UpperCamelCase__  :   int						 =						['''pixel_values''']



       def __init__(		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					bool = True					,		__SCREAMING_SNAKE_CASE							:					Optional[Dict[str, int]] = None					,		__SCREAMING_SNAKE_CASE							:					PILImageResampling = PILImageResampling.BILINEAR					,		__SCREAMING_SNAKE_CASE							:					bool = True					,		__SCREAMING_SNAKE_CASE							:					Dict[str, int] = None					,		__SCREAMING_SNAKE_CASE							:					bool = True					,		__SCREAMING_SNAKE_CASE							:					Union[int, float] = 1 / 255					,		__SCREAMING_SNAKE_CASE							:					bool = True					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[float, List[float]]] = None					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[float, List[float]]] = None					,		**__SCREAMING_SNAKE_CASE							:					Optional[int]					,		):


           '''simple docstring'''

           super().__init__(**__SCREAMING_SNAKE_CASE)
           __a							=    size if size is not None else {'''shortest_edge''': 256}
           __a							=    get_size_dict(__SCREAMING_SNAKE_CASE					,		default_to_square=__SCREAMING_SNAKE_CASE)
           __a							=    crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
           __a							=    get_size_dict(__SCREAMING_SNAKE_CASE					,		param_name='''crop_size''')
           __a							=    do_resize
           __a							=    size
           __a							=    resample
           __a							=    do_center_crop
           __a							=    crop_size
           __a							=    do_rescale
           __a							=    rescale_factor
           __a							=    do_normalize
           __a							=    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
           __a							=    image_std if image_std is not None else IMAGENET_STANDARD_STD



       def 		_lowerCamelCase      (		self							:					Dict					,		__SCREAMING_SNAKE_CASE							:					np.ndarray					,		__SCREAMING_SNAKE_CASE							:					Dict[str, int]					,		__SCREAMING_SNAKE_CASE							:					PILImageResampling = PILImageResampling.BICUBIC					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[str, ChannelDimension]] = None					,		**__SCREAMING_SNAKE_CASE							:					List[Any]					,		):


           '''simple docstring'''

           __a							=    get_size_dict(__SCREAMING_SNAKE_CASE					,		default_to_square=__SCREAMING_SNAKE_CASE)
           if "shortest_edge" not in size:
               raise ValueError(F'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}')
           __a							=    get_resize_output_image_size(__SCREAMING_SNAKE_CASE					,		size=size['''shortest_edge''']					,		default_to_square=__SCREAMING_SNAKE_CASE)
           return resize(__SCREAMING_SNAKE_CASE					,		size=__SCREAMING_SNAKE_CASE					,		resample=__SCREAMING_SNAKE_CASE					,		data_format=__SCREAMING_SNAKE_CASE					,		**__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					str					,		__SCREAMING_SNAKE_CASE							:					np.ndarray					,		__SCREAMING_SNAKE_CASE							:					Dict[str, int]					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[str, ChannelDimension]] = None					,		**__SCREAMING_SNAKE_CASE							:					List[Any]					,		):


           '''simple docstring'''

           __a							=    get_size_dict(__SCREAMING_SNAKE_CASE)
           if "height" not in size or "width" not in size:
               raise ValueError(F'The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}')
           return center_crop(__SCREAMING_SNAKE_CASE					,		size=(size['''height'''], size['''width'''])					,		data_format=__SCREAMING_SNAKE_CASE					,		**__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					np.ndarray					,		__SCREAMING_SNAKE_CASE							:					float					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[str, ChannelDimension]] = None					,		**__SCREAMING_SNAKE_CASE							:					str):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					np.ndarray					,		__SCREAMING_SNAKE_CASE							:					Union[float, List[float]]					,		__SCREAMING_SNAKE_CASE							:					Union[float, List[float]]					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[str, ChannelDimension]] = None					,		**__SCREAMING_SNAKE_CASE							:					int					,		):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					ImageInput					,		__SCREAMING_SNAKE_CASE							:					Optional[bool] = None					,		__SCREAMING_SNAKE_CASE							:					Dict[str, int] = None					,		__SCREAMING_SNAKE_CASE							:					PILImageResampling = None					,		__SCREAMING_SNAKE_CASE							:					bool = None					,		__SCREAMING_SNAKE_CASE							:					Dict[str, int] = None					,		__SCREAMING_SNAKE_CASE							:					Optional[bool] = None					,		__SCREAMING_SNAKE_CASE							:					Optional[float] = None					,		__SCREAMING_SNAKE_CASE							:					Optional[bool] = None					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[float, List[float]]] = None					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[float, List[float]]] = None					,		__SCREAMING_SNAKE_CASE							:					Optional[Union[str, TensorType]] = None					,		__SCREAMING_SNAKE_CASE							:					Union[str, ChannelDimension] = ChannelDimension.FIRST					,		**__SCREAMING_SNAKE_CASE							:					List[Any]					,		):


           '''simple docstring'''

           __a							=    do_resize if do_resize is not None else self.do_resize
           __a							=    size if size is not None else self.size
           __a							=    get_size_dict(__SCREAMING_SNAKE_CASE					,		default_to_square=__SCREAMING_SNAKE_CASE)
           __a							=    resample if resample is not None else self.resample
           __a							=    do_center_crop if do_center_crop is not None else self.do_center_crop
           __a							=    crop_size if crop_size is not None else self.crop_size
           __a							=    get_size_dict(__SCREAMING_SNAKE_CASE					,		param_name='''crop_size''')
           __a							=    do_rescale if do_rescale is not None else self.do_rescale
           __a							=    rescale_factor if rescale_factor is not None else self.rescale_factor
           __a							=    do_normalize if do_normalize is not None else self.do_normalize
           __a							=    image_mean if image_mean is not None else self.image_mean
           __a							=    image_std if image_std is not None else self.image_std

           __a							=    make_list_of_images(__SCREAMING_SNAKE_CASE)

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

           # All transformations expect numpy arrays.
           __a							=    [to_numpy_array(__SCREAMING_SNAKE_CASE) for image in images]

           if do_resize:
               __a							=    [self.resize(image=__SCREAMING_SNAKE_CASE					,		size=__SCREAMING_SNAKE_CASE					,		resample=__SCREAMING_SNAKE_CASE) for image in images]

           if do_center_crop:
               __a							=    [self.center_crop(image=__SCREAMING_SNAKE_CASE					,		size=__SCREAMING_SNAKE_CASE) for image in images]

           if do_rescale:
               __a							=    [self.rescale(image=__SCREAMING_SNAKE_CASE					,		scale=__SCREAMING_SNAKE_CASE) for image in images]

           if do_normalize:
               __a							=    [self.normalize(image=__SCREAMING_SNAKE_CASE					,		mean=__SCREAMING_SNAKE_CASE					,		std=__SCREAMING_SNAKE_CASE) for image in images]

           __a							=    [to_channel_dimension_format(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE) for image in images]

           __a							=    {'''pixel_values''': images}
           return BatchFeature(data=__SCREAMING_SNAKE_CASE					,		tensor_type=__SCREAMING_SNAKE_CASE)





       def 		_lowerCamelCase      (		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					List[Tuple] = None):


           '''simple docstring'''

           __a							=    outputs.logits

           # Resize logits and compute semantic segmentation maps
           if target_sizes is not None:
               if len(__SCREAMING_SNAKE_CASE) != len(__SCREAMING_SNAKE_CASE):
                   raise ValueError(
                       '''Make sure that you pass in as many target sizes as the batch dimension of the logits''')

               if is_torch_tensor(__SCREAMING_SNAKE_CASE):
                   __a							=    target_sizes.numpy()

               __a							=    []

               for idx in range(len(__SCREAMING_SNAKE_CASE)):
                   __a							=    torch.nn.functional.interpolate(
                       logits[idx].unsqueeze(dim=0)					,		size=target_sizes[idx]					,		mode='''bilinear'''					,		align_corners=__SCREAMING_SNAKE_CASE)
                   __a							=    resized_logits[0].argmax(dim=0)
                   semantic_segmentation.append(__SCREAMING_SNAKE_CASE)
           else:
               __a							=    logits.argmax(dim=1)
               __a							=    [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0])]

           return semantic_segmentation










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


__snake_case						:Dict						=					logging.get_logger(__name__)

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

class    _A	(     __UpperCAmelCase   ):
       UpperCamelCase__  :   List[str]						 =						'''gptsan-japanese'''
       UpperCamelCase__  :   Dict						 =						[
           '''past_key_values''',
       ]
       UpperCamelCase__  :   Dict						 =						{
           '''hidden_size''': '''d_model''',
           '''num_attention_heads''': '''num_heads''',
           '''num_hidden_layers''': '''num_layers''',
       }



       def __init__(		self							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=36_000					,		__SCREAMING_SNAKE_CASE							:					Tuple=1_280					,		__SCREAMING_SNAKE_CASE							:					List[Any]=1_024					,		__SCREAMING_SNAKE_CASE							:					List[Any]=8_192					,		__SCREAMING_SNAKE_CASE							:					str=4_096					,		__SCREAMING_SNAKE_CASE							:					Any=128					,		__SCREAMING_SNAKE_CASE							:					int=10					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=0					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=16					,		__SCREAMING_SNAKE_CASE							:					List[Any]=16					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=128					,		__SCREAMING_SNAKE_CASE							:					Tuple=0.0					,		__SCREAMING_SNAKE_CASE							:					List[Any]=1E-5					,		__SCREAMING_SNAKE_CASE							:					str=False					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=0.0					,		__SCREAMING_SNAKE_CASE							:					List[str]="float32"					,		__SCREAMING_SNAKE_CASE							:					List[str]=False					,		__SCREAMING_SNAKE_CASE							:					Any=False					,		__SCREAMING_SNAKE_CASE							:					Any=False					,		__SCREAMING_SNAKE_CASE							:					int=0.0_02					,		__SCREAMING_SNAKE_CASE							:					Any=False					,		__SCREAMING_SNAKE_CASE							:					Tuple=True					,		__SCREAMING_SNAKE_CASE							:					int=35_998					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=35_995					,		__SCREAMING_SNAKE_CASE							:					List[str]=35_999					,		**__SCREAMING_SNAKE_CASE							:					List[str]					,		):


           '''simple docstring'''

           __a							=    vocab_size
           __a							=    max_position_embeddings
           __a							=    d_model
           __a							=    d_ff
           __a							=    d_ext
           __a							=    d_spout
           __a							=    num_switch_layers
           __a							=    num_ext_layers
           __a							=    num_switch_layers + num_ext_layers
           __a							=    num_heads
           __a							=    num_experts
           __a							=    expert_capacity
           __a							=    dropout_rate
           __a							=    layer_norm_epsilon
           __a							=    router_bias
           __a							=    router_jitter_noise
           __a							=    router_dtype
           __a							=    router_ignore_padding_tokens
           __a							=    output_hidden_states
           __a							=    output_attentions
           __a							=    initializer_factor
           __a							=    output_router_logits
           __a							=    use_cache

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





