
"""simple docstring"""





from typing import Dict, List, Optional, 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_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_batched,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__magic_name__       =			logging.get_logger(__name__)
class 						SCREAMING_SNAKE_CASE_ (						__a ):




		"""simple docstring"""





		__lowercase							:  Dict						   =		['''pixel_values''']




		def __init__(     self							,  lowerCAmelCase__ = True							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = PILImageResampling.BICUBIC							,  lowerCAmelCase__ = True							,  lowerCAmelCase__ = True							,  lowerCAmelCase__ = 1 / 2_5_5							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = True							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  **lowerCAmelCase__							,  ):
				super().__init__(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = size if size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
				__SCREAMING_SNAKE_CASE            = get_size_dict(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
				__SCREAMING_SNAKE_CASE            = get_size_dict(lowerCAmelCase__							,  default_to_square=lowerCAmelCase__							,  param_name="""crop_size""")

				__SCREAMING_SNAKE_CASE            = do_resize
				__SCREAMING_SNAKE_CASE            = do_rescale
				__SCREAMING_SNAKE_CASE            = do_normalize
				__SCREAMING_SNAKE_CASE            = do_center_crop
				__SCREAMING_SNAKE_CASE            = crop_size
				__SCREAMING_SNAKE_CASE            = size
				__SCREAMING_SNAKE_CASE            = resample
				__SCREAMING_SNAKE_CASE            = rescale_factor
				__SCREAMING_SNAKE_CASE            = image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
				__SCREAMING_SNAKE_CASE            = image_std if image_std is not None else IMAGENET_DEFAULT_STD




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__ = PILImageResampling.BILINEAR							,  lowerCAmelCase__ = None							,  **lowerCAmelCase__							,  ):
				__SCREAMING_SNAKE_CASE            = get_size_dict(lowerCAmelCase__)

				if "shortest_edge" in size:
						__SCREAMING_SNAKE_CASE            = get_resize_output_image_size(lowerCAmelCase__							,  size=size["""shortest_edge"""]							,  default_to_square=lowerCAmelCase__)
						# size = get_resize_output_image_size(image, size["shortest_edge"], size["longest_edge"])
				elif "height" in size and "width" in size:
						__SCREAMING_SNAKE_CASE            = (size["""height"""], size["""width"""])
				else:
						raise ValueError(f"Size must contain 'height' and 'width' keys or 'shortest_edge' key. Got {size.keys()}")
				return resize(lowerCAmelCase__							,  size=lowerCAmelCase__							,  resample=lowerCAmelCase__							,  data_format=lowerCAmelCase__							,  **lowerCAmelCase__)




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__ = None							,  **lowerCAmelCase__							,  ):
				__SCREAMING_SNAKE_CASE            = 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, width). Got {size.keys()}")
				return center_crop(lowerCAmelCase__							,  size=(size["""height"""], size["""width"""])							,  data_format=lowerCAmelCase__							,  **lowerCAmelCase__)




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__ = None							,  **lowerCAmelCase__):
				return rescale(lowerCAmelCase__							,  scale=lowerCAmelCase__							,  data_format=lowerCAmelCase__							,  **lowerCAmelCase__)




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__ = None							,  **lowerCAmelCase__							,  ):
				return normalize(lowerCAmelCase__							,  mean=lowerCAmelCase__							,  std=lowerCAmelCase__							,  data_format=lowerCAmelCase__							,  **lowerCAmelCase__)




		def 	snake_case_     (     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__							,  ):
				__SCREAMING_SNAKE_CASE            = do_resize if do_resize is not None else self.do_resize
				__SCREAMING_SNAKE_CASE            = do_rescale if do_rescale is not None else self.do_rescale
				__SCREAMING_SNAKE_CASE            = do_normalize if do_normalize is not None else self.do_normalize
				__SCREAMING_SNAKE_CASE            = do_center_crop if do_center_crop is not None else self.do_center_crop
				__SCREAMING_SNAKE_CASE            = crop_size if crop_size is not None else self.crop_size
				__SCREAMING_SNAKE_CASE            = get_size_dict(lowerCAmelCase__							,  param_name="""crop_size"""							,  default_to_square=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = resample if resample is not None else self.resample
				__SCREAMING_SNAKE_CASE            = rescale_factor if rescale_factor is not None else self.rescale_factor
				__SCREAMING_SNAKE_CASE            = image_mean if image_mean is not None else self.image_mean
				__SCREAMING_SNAKE_CASE            = image_std if image_std is not None else self.image_std

				__SCREAMING_SNAKE_CASE            = size if size is not None else self.size
				__SCREAMING_SNAKE_CASE            = get_size_dict(lowerCAmelCase__)

				if not is_batched(lowerCAmelCase__):
						__SCREAMING_SNAKE_CASE            = [images]

				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.""")

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

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

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

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

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

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

				__SCREAMING_SNAKE_CASE            = {"""pixel_values""": images}
				return BatchFeature(data=lowerCAmelCase__							,  tensor_type=lowerCAmelCase__)







'''simple docstring'''






import torch
from torch import nn






class 			lowercase_	(nn.Module      ):




  """simple docstring"""




  def __init__(      self   :     Optional[int]					,lowercase__   :     List[str]					,lowercase__   :     Any					,lowercase__   :     Union[str, Any]					,lowercase__   :     Optional[int]					,lowercase__   :     Optional[int]=1					,lowercase__   :     Optional[Any]=False			):
   super().__init__()

   __lowercase							  = n_token
   __lowercase							  = d_embed
   __lowercase							  = d_proj

   __lowercase							  = cutoffs + [n_token]
   __lowercase							  = [0] + self.cutoffs
   __lowercase							  = div_val

   __lowercase							  = self.cutoffs[0]
   __lowercase							  = len(self.cutoffs			) - 1
   __lowercase							  = self.shortlist_size + self.n_clusters

   if self.n_clusters > 0:
    __lowercase							  = nn.Parameter(torch.zeros(self.n_clusters					,self.d_embed			)			)
    __lowercase							  = nn.Parameter(torch.zeros(self.n_clusters			)			)

   __lowercase							  = nn.ModuleList()
   __lowercase							  = 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			)			):
     __lowercase  ,	__lowercase							  = self.cutoff_ends[i], self.cutoff_ends[i + 1]
     __lowercase							  = 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			)			)

   __lowercase							  = keep_order






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[int]					,lowercase__   :     List[Any]					,lowercase__   :     Dict					,lowercase__   :     List[Any]					,lowercase__   :     Any			):
   if proj is None:
    __lowercase							  = nn.functional.linear(lowercase__					,lowercase__					,bias=lowercase__			)
   else:
    # if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
    __lowercase							  = nn.functional.linear(lowercase__					,proj.t().contiguous()			)
    __lowercase							  = 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 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]					,lowercase__   :     Optional[Any]					,lowercase__   :     Any=None					,lowercase__   :     List[str]=False			):

   if labels is not None:
    # Shift so that tokens < n predict n
    __lowercase							  = hidden[..., :-1, :].contiguous()
    __lowercase							  = labels[..., 1:].contiguous()
    __lowercase							  = hidden.view(-1					,hidden.size(-1			)			)
    __lowercase							  = 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:
    __lowercase							  = hidden.view(-1					,hidden.size(-1			)			)

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

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

     weights.append(lowercase__			)
     biases.append(lowercase__			)

    __lowercase  ,	__lowercase  ,	__lowercase							  = weights[0], biases[0], self.out_projs[0]

    __lowercase							  = self._compute_logit(lowercase__					,lowercase__					,lowercase__					,lowercase__			)
    __lowercase							  = nn.functional.log_softmax(lowercase__					,dim=1			)

    if labels is None:
     __lowercase							  = hidden.new_empty((head_logit.size(0			), self.n_token)			)
    else:
     __lowercase							  = torch.zeros_like(lowercase__					,dtype=hidden.dtype					,device=hidden.device			)

    __lowercase							  = 0
    __lowercase							  = [0] + self.cutoffs
    for i in range(len(lowercase__			) - 1			):
     __lowercase  ,	__lowercase							  = cutoff_values[i], cutoff_values[i + 1]

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

      if indices_i.numel() == 0:
       continue

      __lowercase							  = labels.index_select(0					,lowercase__			) - l_idx
      __lowercase							  = head_logprob.index_select(0					,lowercase__			)
      __lowercase							  = hidden.index_select(0					,lowercase__			)
     else:
      __lowercase							  = hidden

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

      __lowercase							  = self._compute_logit(lowercase__					,lowercase__					,lowercase__					,lowercase__			)
      __lowercase							  = nn.functional.log_softmax(lowercase__					,dim=1			)
      __lowercase							  = self.cutoffs[0] + i - 1  # No probability for the head cluster
      if labels is not None:
       __lowercase							  = head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather(
           1					,target_i[:, None]			).squeeze(1			)
      else:
       __lowercase							  = head_logprob[:, cluster_prob_idx, None] + tail_logprob_i
       __lowercase							  = 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 					SCREAMING_SNAKE_CASE      (      self   :     Any					,lowercase__   :     Union[str, Any]			):
   if self.n_clusters == 0:
    __lowercase							  = 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
    __lowercase  ,	__lowercase							  = [], []
    for i in range(len(self.cutoffs			)			):
     if self.div_val == 1:
      __lowercase  ,	__lowercase							  = self.cutoff_ends[i], self.cutoff_ends[i + 1]
      __lowercase							  = self.out_layers[0].weight[l_idx:r_idx]
      __lowercase							  = self.out_layers[0].bias[l_idx:r_idx]
     else:
      __lowercase							  = self.out_layers[i].weight
      __lowercase							  = self.out_layers[i].bias

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

     weights.append(lowercase__			)
     biases.append(lowercase__			)

    __lowercase  ,	__lowercase  ,	__lowercase							  = weights[0], biases[0], self.out_projs[0]
    __lowercase							  = self._compute_logit(lowercase__					,lowercase__					,lowercase__					,lowercase__			)

    __lowercase							  = hidden.new_empty((head_logit.size(0			), self.n_token)			)
    __lowercase							  = nn.functional.log_softmax(lowercase__					,dim=1			)

    __lowercase							  = [0] + self.cutoffs
    for i in range(len(lowercase__			) - 1			):
     __lowercase  ,	__lowercase							  = cutoff_values[i], cutoff_values[i + 1]

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

      __lowercase							  = self._compute_logit(lowercase__					,lowercase__					,lowercase__					,lowercase__			)
      __lowercase							  = nn.functional.log_softmax(lowercase__					,dim=1			)

      __lowercase							  = head_logprob[:, -i] + tail_logprob_i
      __lowercase							  = logprob_i

    return out

