




from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


__A								=       logging.get_logger(__name__)

__A								=       {
    "EleutherAI/gpt-j-6B": "https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json",
    # See all GPT-J models at https://huggingface.co/models?filter=gpt_j
}







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			snake_case_  						=			'''gptj'''
			snake_case_  						=			{
			    '''max_position_embeddings''': '''n_positions''',
			    '''hidden_size''': '''n_embd''',
			    '''num_attention_heads''': '''n_head''',
			    '''num_hidden_layers''': '''n_layer''',
			}


			def __init__( self     ,		lowerCamelCase__=50_400     ,		lowerCamelCase__=2_048     ,		lowerCamelCase__=4_096     ,		lowerCamelCase__=28     ,		lowerCamelCase__=16     ,		lowerCamelCase__=64     ,		lowerCamelCase__=None     ,		lowerCamelCase__="gelu_new"     ,		lowerCamelCase__=0.0     ,		lowerCamelCase__=0.0     ,		lowerCamelCase__=0.0     ,		lowerCamelCase__=1e-5     ,		lowerCamelCase__=0.02     ,		lowerCamelCase__=True     ,		lowerCamelCase__=50_256     ,		lowerCamelCase__=50_256     ,		lowerCamelCase__=False     ,		**lowerCamelCase__     ,		)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       vocab_size
							__lowerCamelCase									=       n_positions
							__lowerCamelCase									=       n_embd
							__lowerCamelCase									=       n_layer
							__lowerCamelCase									=       n_head
							__lowerCamelCase									=       n_inner
							__lowerCamelCase									=       rotary_dim
							__lowerCamelCase									=       activation_function
							__lowerCamelCase									=       resid_pdrop
							__lowerCamelCase									=       embd_pdrop
							__lowerCamelCase									=       attn_pdrop
							__lowerCamelCase									=       layer_norm_epsilon
							__lowerCamelCase									=       initializer_range
							__lowerCamelCase									=       use_cache

							__lowerCamelCase									=       bos_token_id
							__lowerCamelCase									=       eos_token_id

							super().__init__(
							    bos_token_id=lowerCamelCase__     ,		eos_token_id=lowerCamelCase__     ,		tie_word_embeddings=lowerCamelCase__     ,		**lowerCamelCase__				)







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			def __init__( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = "default"     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = False     ,		)       -> List[Any]:



							'''simple docstring'''
							super().__init__(lowerCamelCase__     ,		task=lowerCamelCase__     ,		patching_specs=lowerCamelCase__     ,		use_past=lowerCamelCase__				)
							if not getattr(self._config     ,		'pad_token_id'     ,		lowerCamelCase__				):
											# TODO: how to do that better?
											__lowerCamelCase									=       0


			@property
			def  lowercase_       ( self				)       -> Mapping[str, Mapping[int, str]]:



							'''simple docstring'''
							__lowerCamelCase									=       OrderedDict({'input_ids': {0: 'batch', 1: 'sequence'}}				)
							if self.use_past:
											self.fill_with_past_key_values_(lowerCamelCase__     ,		direction='inputs'				)
											__lowerCamelCase									=       {0: 'batch', 1: 'past_sequence + sequence'}
							else:
											__lowerCamelCase									=       {0: 'batch', 1: 'sequence'}

							return common_inputs


			@property
			def  lowercase_       ( self				)       -> int:



							'''simple docstring'''
							return self._config.n_layer


			@property
			def  lowercase_       ( self				)       -> int:



							'''simple docstring'''
							return self._config.n_head


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = -1     ,		lowerCamelCase__ = -1     ,		lowerCamelCase__ = False     ,		lowerCamelCase__ = None     ,		)       -> Mapping[str, Any]:



							'''simple docstring'''
							__lowerCamelCase									=       super(lowerCamelCase__     ,		self				).generate_dummy_inputs(
							    lowerCamelCase__     ,		batch_size=lowerCamelCase__     ,		seq_length=lowerCamelCase__     ,		is_pair=lowerCamelCase__     ,		framework=lowerCamelCase__				)

							# We need to order the input in the way they appears in the forward()
							__lowerCamelCase									=       OrderedDict({'input_ids': common_inputs['input_ids']}				)

							# Need to add the past_keys
							if self.use_past:
											if not is_torch_available():
															raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'				)
											else:
															import torch

															__lowerCamelCase			,		__lowerCamelCase									=       common_inputs['input_ids'].shape
															# Not using the same length for past_key_values
															__lowerCamelCase									=       seqlen + 2
															__lowerCamelCase									=       (
															    batch,
															    self.num_attention_heads,
															    past_key_values_length,
															    self._config.hidden_size // self.num_attention_heads,
															)
															__lowerCamelCase									=       [
															    (torch.zeros(lowerCamelCase__				), torch.zeros(lowerCamelCase__				)) for _ in range(self.num_layers				)
															]

							__lowerCamelCase									=       common_inputs['attention_mask']
							if self.use_past:
											__lowerCamelCase									=       ordered_inputs['attention_mask'].dtype
											__lowerCamelCase									=       torch.cat(
											    [ordered_inputs['attention_mask'], torch.ones(lowerCamelCase__     ,		lowerCamelCase__     ,		dtype=lowerCamelCase__				)]     ,		dim=1				)

							return ordered_inputs






			@property
			def  lowercase_       ( self				)       -> int:



							'''simple docstring'''
							return 13








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


__A								=       logging.get_logger(__name__)







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			snake_case_  						=			['''pixel_values''']


			def __init__( self     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = PILImageResampling.BILINEAR     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = 1 / 255     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> None:



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


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = PILImageResampling.BICUBIC     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



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


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__				)
							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(lowerCamelCase__     ,		size=(size['height'], size['width'])     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__				)       -> np.ndarray:



							'''simple docstring'''
							return rescale(lowerCamelCase__     ,		scale=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							return normalize(lowerCamelCase__     ,		mean=lowerCamelCase__     ,		std=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = ChannelDimension.FIRST     ,		**lowerCamelCase__     ,		)       -> str:



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

							__lowerCamelCase									=       make_list_of_images(lowerCamelCase__				)

							if not valid_images(lowerCamelCase__				):
											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.
							__lowerCamelCase									=       [to_numpy_array(lowerCamelCase__				) for image in images]

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

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

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

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

							__lowerCamelCase									=       [to_channel_dimension_format(lowerCamelCase__     ,		lowerCamelCase__				) for image in images]

							__lowerCamelCase									=       {'pixel_values': images}
							return BatchFeature(data=lowerCamelCase__     ,		tensor_type=lowerCamelCase__				)






			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = None				)       -> Optional[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       outputs.logits

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

											if is_torch_tensor(lowerCamelCase__				):
															__lowerCamelCase									=       target_sizes.numpy()

											__lowerCamelCase									=       []

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

							return semantic_segmentation


