"""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 convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
    import PIL


UpperCAmelCase__  		=						logging.get_logger(__name__)


class        a				(		lowerCAmelCase_   ):
    _snake_case     :  Optional[Any]     							=							['pixel_values']


    def __init__(					self	:  Tuple   ,				__lowerCAmelCase	:  bool = True   ,				__lowerCAmelCase	:  Dict[str, int] = None   ,				__lowerCAmelCase	:  PILImageResampling = PILImageResampling.BICUBIC   ,				__lowerCAmelCase	:  bool = True   ,				__lowerCAmelCase	:  Union[int, float] = 1 / 255   ,				__lowerCAmelCase	:  bool = True   ,				__lowerCAmelCase	:  Optional[Union[float, List[float]]] = None   ,				__lowerCAmelCase	:  Optional[Union[float, List[float]]] = None   ,				__lowerCAmelCase	:  bool = True   ,				**__lowerCAmelCase	:  Union[str, Any]   ,				):
      super().__init__(**__lowerCAmelCase					)
      _UpperCAmelCase						 =      size if size is not None else {"""height""": 384, """width""": 384}
      _UpperCAmelCase						 =      get_size_dict(__lowerCAmelCase   ,				default_to_square=__lowerCAmelCase					)

      _UpperCAmelCase						 =      do_resize
      _UpperCAmelCase						 =      size
      _UpperCAmelCase						 =      resample
      _UpperCAmelCase						 =      do_rescale
      _UpperCAmelCase						 =      rescale_factor
      _UpperCAmelCase						 =      do_normalize
      _UpperCAmelCase						 =      image_mean if image_mean is not None else OPENAI_CLIP_MEAN
      _UpperCAmelCase						 =      image_std if image_std is not None else OPENAI_CLIP_STD
      _UpperCAmelCase						 =      do_convert_rgb


    def      lowerCAmelCase_  (					self	:  List[Any]   ,				__lowerCAmelCase	:  np.ndarray   ,				__lowerCAmelCase	:  Dict[str, int]   ,				__lowerCAmelCase	:  PILImageResampling = PILImageResampling.BICUBIC   ,				__lowerCAmelCase	:  Optional[Union[str, ChannelDimension]] = None   ,				**__lowerCAmelCase	:  int   ,				):
      _UpperCAmelCase						 =      get_size_dict(__lowerCAmelCase   ,				default_to_square=__lowerCAmelCase					)
      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()}'''					)
      _UpperCAmelCase						 =      (size["""height"""], size["""width"""])
      return resize(__lowerCAmelCase   ,				size=__lowerCAmelCase   ,				resample=__lowerCAmelCase   ,				data_format=__lowerCAmelCase   ,				**__lowerCAmelCase					)


    def      lowerCAmelCase_  (					self	:  int   ,				__lowerCAmelCase	:  np.ndarray   ,				__lowerCAmelCase	:  Union[int, float]   ,				__lowerCAmelCase	:  Optional[Union[str, ChannelDimension]] = None   ,				**__lowerCAmelCase	:  Union[str, Any]   ,				):
      return rescale(__lowerCAmelCase   ,				scale=__lowerCAmelCase   ,				data_format=__lowerCAmelCase   ,				**__lowerCAmelCase					)


    def      lowerCAmelCase_  (					self	:  List[str]   ,				__lowerCAmelCase	:  np.ndarray   ,				__lowerCAmelCase	:  Union[float, List[float]]   ,				__lowerCAmelCase	:  Union[float, List[float]]   ,				__lowerCAmelCase	:  Optional[Union[str, ChannelDimension]] = None   ,				**__lowerCAmelCase	:  str   ,				):
      return normalize(__lowerCAmelCase   ,				mean=__lowerCAmelCase   ,				std=__lowerCAmelCase   ,				data_format=__lowerCAmelCase   ,				**__lowerCAmelCase					)


    def      lowerCAmelCase_  (					self	:  int   ,				__lowerCAmelCase	:  ImageInput   ,				__lowerCAmelCase	:  Optional[bool] = None   ,				__lowerCAmelCase	:  Optional[Dict[str, int]] = None   ,				__lowerCAmelCase	:  PILImageResampling = None   ,				__lowerCAmelCase	:  Optional[bool] = None   ,				__lowerCAmelCase	:  Optional[float] = None   ,				__lowerCAmelCase	:  Optional[bool] = None   ,				__lowerCAmelCase	:  Optional[Union[float, List[float]]] = None   ,				__lowerCAmelCase	:  Optional[Union[float, List[float]]] = None   ,				__lowerCAmelCase	:  Optional[Union[str, TensorType]] = None   ,				__lowerCAmelCase	:  bool = None   ,				__lowerCAmelCase	:  ChannelDimension = ChannelDimension.FIRST   ,				**__lowerCAmelCase	:  Any   ,				):
      _UpperCAmelCase						 =      do_resize if do_resize is not None else self.do_resize
      _UpperCAmelCase						 =      resample if resample is not None else self.resample
      _UpperCAmelCase						 =      do_rescale if do_rescale is not None else self.do_rescale
      _UpperCAmelCase						 =      rescale_factor if rescale_factor is not None else self.rescale_factor
      _UpperCAmelCase						 =      do_normalize if do_normalize is not None else self.do_normalize
      _UpperCAmelCase						 =      image_mean if image_mean is not None else self.image_mean
      _UpperCAmelCase						 =      image_std if image_std is not None else self.image_std
      _UpperCAmelCase						 =      do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

      _UpperCAmelCase						 =      size if size is not None else self.size
      _UpperCAmelCase						 =      get_size_dict(__lowerCAmelCase   ,				default_to_square=__lowerCAmelCase					)

      _UpperCAmelCase						 =      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 or resample is None:
        raise ValueError("""Size and resample 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_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."""					)

      # PIL RGBA images are converted to RGB
      if do_convert_rgb:
        _UpperCAmelCase						 =      [convert_to_rgb(__lowerCAmelCase					) for image in images]

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

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

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

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

      _UpperCAmelCase						 =      [to_channel_dimension_format(__lowerCAmelCase   ,				__lowerCAmelCase					) for image in images]

      _UpperCAmelCase						 =      BatchFeature(data={"""pixel_values""": images}   ,				tensor_type=__lowerCAmelCase					)

      return encoded_outputs

"""simple docstring"""


import torch
from torch import nn


class        a				(		nn.Module   ):


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

      _UpperCAmelCase						 =      n_token
      _UpperCAmelCase						 =      d_embed
      _UpperCAmelCase						 =      d_proj

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

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

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

      _UpperCAmelCase						 =      nn.ModuleList()
      _UpperCAmelCase						 =      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(__lowerCAmelCase   ,				__lowerCAmelCase					)					)					)
          else:
            self.out_projs.append(__lowerCAmelCase					)

        self.out_layers.append(nn.Linear(__lowerCAmelCase   ,				__lowerCAmelCase					)					)
      else:
        for i in range(len(self.cutoffs					)					):
          _UpperCAmelCase ,				_UpperCAmelCase						 =      self.cutoff_ends[i], self.cutoff_ends[i + 1]
          _UpperCAmelCase						 =      d_embed // (div_val**i)

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

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

      _UpperCAmelCase						 =      keep_order


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

      return logit


    def      lowerCAmelCase_  (					self	:  List[Any]   ,				__lowerCAmelCase	:  Optional[int]   ,				__lowerCAmelCase	:  Optional[Any]=None   ,				__lowerCAmelCase	:  Union[str, Any]=False					):

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

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

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

          weights.append(__lowerCAmelCase					)
          biases.append(__lowerCAmelCase					)

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

        _UpperCAmelCase						 =      self._compute_logit(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)
        _UpperCAmelCase						 =      nn.functional.log_softmax(__lowerCAmelCase   ,				dim=1					)

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

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

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

            if indices_i.numel() == 0:
              continue

            _UpperCAmelCase						 =      labels.index_select(0   ,				__lowerCAmelCase					) - l_idx
            _UpperCAmelCase						 =      head_logprob.index_select(0   ,				__lowerCAmelCase					)
            _UpperCAmelCase						 =      hidden.index_select(0   ,				__lowerCAmelCase					)
          else:
            _UpperCAmelCase						 =      hidden

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

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

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

      return out


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

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

          weights.append(__lowerCAmelCase					)
          biases.append(__lowerCAmelCase					)

        _UpperCAmelCase ,				_UpperCAmelCase ,				_UpperCAmelCase						 =      weights[0], biases[0], self.out_projs[0]
        _UpperCAmelCase						 =      self._compute_logit(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)

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

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

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

            _UpperCAmelCase						 =      self._compute_logit(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)
            _UpperCAmelCase						 =      nn.functional.log_softmax(__lowerCAmelCase   ,				dim=1					)

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

        return out
