



'''simple docstring'''




import torch
from torch import nn







class      _lowerCAmelCase							(      nn.Module			):


	def __init__(self	,				lowercase	,				lowercase	,				lowercase	,				lowercase	,				lowercase=1	,				lowercase=False							):
				super().__init__()

				A_     :						str     =					n_token
				A_     :						Dict     =					d_embed
				A_     :						Any     =					d_proj

				A_     :						List[str]     =					cutoffs + [n_token]
				A_     :						List[str]     =					[0] + self.cutoffs
				A_     :						Union[str, Any]     =					div_val

				A_     :						Optional[Any]     =					self.cutoffs[0]
				A_     :						int     =					len(self.cutoffs							) - 1
				A_     :						List[Any]     =					self.shortlist_size + self.n_clusters

				if self.n_clusters > 0:
							A_     :						List[Any]     =					nn.Parameter(torch.zeros(self.n_clusters	,				self.d_embed							)							)
							A_     :						List[str]     =					nn.Parameter(torch.zeros(self.n_clusters							)							)

				A_     :						List[Any]     =					nn.ModuleList()
				A_     :						Tuple     =					nn.ParameterList()

				if div_val == 1:
							for i in range(len(self.cutoffs							)							):
										if d_proj != d_embed:
													self.out_projs.append(nn.Parameter(torch.FloatTensor(lowercase	,				lowercase							)							)							)
										else:
													self.out_projs.append(lowercase							)

							self.out_layers.append(nn.Linear(lowercase	,				lowercase							)							)
				else:
							for i in range(len(self.cutoffs							)							):
										A_,   A_     :						Optional[Any]     =					self.cutoff_ends[i], self.cutoff_ends[i + 1]
										A_     :						Union[str, Any]     =					d_embed // (div_val**i)

										self.out_projs.append(nn.Parameter(torch.FloatTensor(lowercase	,				lowercase							)							)							)

										self.out_layers.append(nn.Linear(lowercase	,				r_idx - l_idx							)							)

				A_     :						Union[str, Any]     =					keep_order


	def    _a     (self	,				lowercase	,				lowercase	,				lowercase	,				lowercase							):
				if proj is None:
							A_     :						Optional[int]     =					nn.functional.linear(lowercase	,				lowercase	,				bias=lowercase							)
				else:
							# if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
							A_     :						Optional[int]     =					nn.functional.linear(lowercase	,				proj.t().contiguous()							)
							A_     :						int     =					nn.functional.linear(lowercase	,				lowercase	,				bias=lowercase							)
							# else:
							#     logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t()))
							#     if bias is not None:
							#         logit = logit + bias

				return logit


	def    _a     (self	,				lowercase	,				lowercase=None	,				lowercase=False							):

				if labels is not None:
							# Shift so that tokens < n predict n
							A_     :						Union[str, Any]     =					hidden[..., :-1, :].contiguous()
							A_     :						Tuple     =					labels[..., 1:].contiguous()
							A_     :						List[Any]     =					hidden.view(-1	,				hidden.size(-1							)							)
							A_     :						Any     =					labels.view(-1							)
							if hidden.size(0							) != labels.size(0							):
										raise RuntimeError("""Input and labels should have the same size in the batch dimension."""							)
				else:
							A_     :						Dict     =					hidden.view(-1	,				hidden.size(-1							)							)

				if self.n_clusters == 0:
							A_     :						Dict     =					self._compute_logit(lowercase	,				self.out_layers[0].weight	,				self.out_layers[0].bias	,				self.out_projs[0]							)
							if labels is not None:
										A_     :						Dict     =					labels != -100
										A_     :						List[Any]     =					torch.zeros_like(lowercase	,				dtype=hidden.dtype	,				device=hidden.device							)
										A_     :						Optional[int]     =					(
										    -nn.functional.log_softmax(lowercase	,				dim=-1							)[mask].gather(1	,				labels[mask].unsqueeze(1							)							).squeeze(1							)
										)
							else:
										A_     :						Optional[int]     =					nn.functional.log_softmax(lowercase	,				dim=-1							)
				else:
							# construct weights and biases
							A_,   A_     :						List[str]     =					[], []
							for i in range(len(self.cutoffs							)							):
										if self.div_val == 1:
													A_,   A_     :						List[Any]     =					self.cutoff_ends[i], self.cutoff_ends[i + 1]
													A_     :						Any     =					self.out_layers[0].weight[l_idx:r_idx]
													A_     :						int     =					self.out_layers[0].bias[l_idx:r_idx]
										else:
													A_     :						Any     =					self.out_layers[i].weight
													A_     :						Union[str, Any]     =					self.out_layers[i].bias

										if i == 0:
													A_     :						str     =					torch.cat([weight_i, self.cluster_weight]	,				dim=0							)
													A_     :						Dict     =					torch.cat([bias_i, self.cluster_bias]	,				dim=0							)

										weights.append(lowercase							)
										biases.append(lowercase							)

							A_,   A_,   A_     :						Optional[int]     =					weights[0], biases[0], self.out_projs[0]

							A_     :						Any     =					self._compute_logit(lowercase	,				lowercase	,				lowercase	,				lowercase							)
							A_     :						Any     =					nn.functional.log_softmax(lowercase	,				dim=1							)

							if labels is None:
										A_     :						Tuple     =					hidden.new_empty((head_logit.size(0							), self.n_token)							)
							else:
										A_     :						Dict     =					torch.zeros_like(lowercase	,				dtype=hidden.dtype	,				device=hidden.device							)

							A_     :						Optional[Any]     =					0
							A_     :						Dict     =					[0] + self.cutoffs
							for i in range(len(lowercase							) - 1							):
										A_,   A_     :						List[str]     =					cutoff_values[i], cutoff_values[i + 1]

										if labels is not None:
													A_     :						str     =					(labels >= l_idx) & (labels < r_idx)
													A_     :						Dict     =					mask_i.nonzero().squeeze()

													if indices_i.numel() == 0:
																continue

													A_     :						List[Any]     =					labels.index_select(0	,				lowercase							) - l_idx
													A_     :						List[str]     =					head_logprob.index_select(0	,				lowercase							)
													A_     :						Any     =					hidden.index_select(0	,				lowercase							)
										else:
													A_     :						int     =					hidden

										if i == 0:
													if labels is not None:
																A_     :						List[Any]     =					head_logprob_i.gather(1	,				target_i[:, None]							).squeeze(1							)
													else:
																A_     :						Union[str, Any]     =					head_logprob[:, : self.cutoffs[0]]
										else:
													A_,   A_,   A_     :						str     =					weights[i], biases[i], self.out_projs[i]

													A_     :						int     =					self._compute_logit(lowercase	,				lowercase	,				lowercase	,				lowercase							)
													A_     :						Union[str, Any]     =					nn.functional.log_softmax(lowercase	,				dim=1							)
													A_     :						Dict     =					self.cutoffs[0] + i - 1  # No probability for the head cluster
													if labels is not None:
																A_     :						Union[str, Any]     =					head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather(
																    1	,				target_i[:, None]							).squeeze(1							)
													else:
																A_     :						str     =					head_logprob[:, cluster_prob_idx, None] + tail_logprob_i
																A_     :						Any     =					logprob_i

										if labels is not None:
													if (hasattr(self	,				"""keep_order"""							) and self.keep_order) or keep_order:
																out.index_copy_(0	,				lowercase	,				-logprob_i							)
													else:
																out[offset : offset + logprob_i.size(0							)].copy_(-logprob_i							)
													offset += logprob_i.size(0							)

				return out


	def    _a     (self	,				lowercase							):
				if self.n_clusters == 0:
							A_     :						Any     =					self._compute_logit(lowercase	,				self.out_layers[0].weight	,				self.out_layers[0].bias	,				self.out_projs[0]							)
							return nn.functional.log_softmax(lowercase	,				dim=-1							)
				else:
							# construct weights and biases
							A_,   A_     :						Any     =					[], []
							for i in range(len(self.cutoffs							)							):
										if self.div_val == 1:
													A_,   A_     :						List[Any]     =					self.cutoff_ends[i], self.cutoff_ends[i + 1]
													A_     :						Tuple     =					self.out_layers[0].weight[l_idx:r_idx]
													A_     :						Optional[int]     =					self.out_layers[0].bias[l_idx:r_idx]
										else:
													A_     :						List[Any]     =					self.out_layers[i].weight
													A_     :						Union[str, Any]     =					self.out_layers[i].bias

										if i == 0:
													A_     :						List[Any]     =					torch.cat([weight_i, self.cluster_weight]	,				dim=0							)
													A_     :						Any     =					torch.cat([bias_i, self.cluster_bias]	,				dim=0							)

										weights.append(lowercase							)
										biases.append(lowercase							)

							A_,   A_,   A_     :						Tuple     =					weights[0], biases[0], self.out_projs[0]
							A_     :						List[str]     =					self._compute_logit(lowercase	,				lowercase	,				lowercase	,				lowercase							)

							A_     :						Any     =					hidden.new_empty((head_logit.size(0							), self.n_token)							)
							A_     :						List[Any]     =					nn.functional.log_softmax(lowercase	,				dim=1							)

							A_     :						int     =					[0] + self.cutoffs
							for i in range(len(lowercase							) - 1							):
										A_,   A_     :						Dict     =					cutoff_values[i], cutoff_values[i + 1]

										if i == 0:
													A_     :						int     =					head_logprob[:, : self.cutoffs[0]]
										else:
													A_,   A_,   A_     :						str     =					weights[i], biases[i], self.out_projs[i]

													A_     :						Union[str, Any]     =					self._compute_logit(lowercase	,				lowercase	,				lowercase	,				lowercase							)
													A_     :						List[str]     =					nn.functional.log_softmax(lowercase	,				dim=1							)

													A_     :						Dict     =					head_logprob[:, -i] + tail_logprob_i
													A_     :						int     =					logprob_i

							return out




'''simple docstring'''




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,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
						import PIL

if is_torch_available():
						import torch


lowerCamelCase							:str       = logging.get_logger(__name__)







class      _lowerCAmelCase							(      __UpperCAmelCase			):
	__SCREAMING_SNAKE_CASE       :		Tuple		      = ['pixel_values']


	def __init__(self	,				lowercase = True	,				lowercase = None	,				lowercase = PILImageResampling.BILINEAR	,				lowercase = True	,				lowercase = 1 / 255	,				lowercase = True	,				lowercase = None	,				lowercase = True	,				**lowercase	,				):
				super().__init__(**lowercase							)
				A_     :						Union[str, Any]     =					size if size is not None else {"""shortest_edge""": 224}
				A_     :						Union[str, Any]     =					get_size_dict(lowercase	,				default_to_square=lowercase							)
				A_     :						Optional[Any]     =					crop_size if crop_size is not None else {"""height""": 256, """width""": 256}
				A_     :						Tuple     =					get_size_dict(lowercase	,				param_name="""crop_size"""							)

				A_     :						List[Any]     =					do_resize
				A_     :						List[str]     =					size
				A_     :						Dict     =					resample
				A_     :						int     =					do_rescale
				A_     :						str     =					rescale_factor
				A_     :						Tuple     =					do_center_crop
				A_     :						Tuple     =					crop_size
				A_     :						List[str]     =					do_flip_channel_order


	def    _a     (self	,				lowercase	,				lowercase	,				lowercase = PIL.Image.BILINEAR	,				lowercase = None	,				**lowercase	,				):
				A_     :						Any     =					get_size_dict(lowercase	,				default_to_square=lowercase							)
				if "shortest_edge" not in size:
							raise ValueError(F'The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}'							)
				A_     :						Any     =					get_resize_output_image_size(lowercase	,				size=size["""shortest_edge"""]	,				default_to_square=lowercase							)
				return resize(lowercase	,				size=lowercase	,				resample=lowercase	,				data_format=lowercase	,				**lowercase							)


	def    _a     (self	,				lowercase	,				lowercase	,				lowercase = None	,				**lowercase	,				):
				A_     :						Tuple     =					get_size_dict(lowercase							)
				if "height" not in size or "width" not in size:
							raise ValueError(F'The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}'							)
				return center_crop(lowercase	,				size=(size["""height"""], size["""width"""])	,				data_format=lowercase	,				**lowercase							)


	def    _a     (self	,				lowercase	,				lowercase	,				lowercase = None	,				**lowercase	,				):
				return rescale(lowercase	,				scale=lowercase	,				data_format=lowercase	,				**lowercase							)


	def    _a     (self	,				lowercase	,				lowercase = None							):
				return flip_channel_order(lowercase	,				data_format=lowercase							)


	def    _a     (self	,				lowercase	,				lowercase = None	,				lowercase = None	,				lowercase = None	,				lowercase = None	,				lowercase = None	,				lowercase = None	,				lowercase = None	,				lowercase = None	,				lowercase = None	,				lowercase = ChannelDimension.FIRST	,				**lowercase	,				):
				A_     :						str     =					do_resize if do_resize is not None else self.do_resize
				A_     :						Optional[int]     =					resample if resample is not None else self.resample
				A_     :						str     =					do_rescale if do_rescale is not None else self.do_rescale
				A_     :						str     =					rescale_factor if rescale_factor is not None else self.rescale_factor
				A_     :						str     =					do_center_crop if do_center_crop is not None else self.do_center_crop
				A_     :						Dict     =					(
				    do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
				)

				A_     :						Union[str, Any]     =					size if size is not None else self.size
				A_     :						Dict     =					get_size_dict(lowercase	,				default_to_square=lowercase							)
				A_     :						Any     =					crop_size if crop_size is not None else self.crop_size
				A_     :						Union[str, Any]     =					get_size_dict(lowercase	,				param_name="""crop_size"""							)

				A_     :						Union[str, Any]     =					make_list_of_images(lowercase							)

				if not valid_images(lowercase							):
							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_rescale and rescale_factor is None:
							raise ValueError("""Rescale factor must be specified if do_rescale is True."""							)

				if do_center_crop and crop_size is None:
							raise ValueError("""Crop size must be specified if do_center_crop is True."""							)

				# All transformations expect numpy arrays.
				A_     :						Optional[Any]     =					[to_numpy_array(lowercase							) for image in images]

				if do_resize:
							A_     :						List[Any]     =					[self.resize(image=lowercase	,				size=lowercase	,				resample=lowercase							) for image in images]

				if do_center_crop:
							A_     :						str     =					[self.center_crop(image=lowercase	,				size=lowercase							) for image in images]

				if do_rescale:
							A_     :						Dict     =					[self.rescale(image=lowercase	,				scale=lowercase							) for image in images]

				# the pretrained checkpoints assume images are BGR, not RGB
				if do_flip_channel_order:
							A_     :						List[str]     =					[self.flip_channel_order(image=lowercase							) for image in images]

				A_     :						List[str]     =					[to_channel_dimension_format(lowercase	,				lowercase							) for image in images]

				A_     :						str     =					{"""pixel_values""": images}
				return BatchFeature(data=lowercase	,				tensor_type=lowercase							)


	def    _a     (self	,				lowercase	,				lowercase = None							):
				A_     :						Optional[Any]     =					outputs.logits

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

							if is_torch_tensor(lowercase							):
										A_     :						Dict     =					target_sizes.numpy()

							A_     :						Union[str, Any]     =					[]

							for idx in range(len(lowercase							)							):
										A_     :						Union[str, Any]     =					torch.nn.functional.interpolate(
										    logits[idx].unsqueeze(dim=0							)	,				size=target_sizes[idx]	,				mode="""bilinear"""	,				align_corners=lowercase							)
										A_     :						Any     =					resized_logits[0].argmax(dim=0							)
										semantic_segmentation.append(lowercase							)
				else:
							A_     :						str     =					logits.argmax(dim=1							)
							A_     :						Optional[Any]     =					[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]							)]

				return semantic_segmentation