






import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
       import torch

if is_vision_available():
       import PIL


__magic_name__   :  Union[str, Any]        =							logging.get_logger(__name__)
def 		lowercase__  (				_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase) ->			Tuple[int, int]:
      """simple docstring"""

      def constraint_to_multiple_of(_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase=0       ,							_UpperCamelCase=None):
            UpperCamelCase					       =  round(val / multiple) * multiple

            if max_val is not None and x > max_val:
                  UpperCamelCase					       =  math.floor(val / multiple) * multiple

            if x < min_val:
                  UpperCamelCase					       =  math.ceil(val / multiple) * multiple

            return x

      UpperCamelCase					       =  (output_size, output_size) if isinstance(_UpperCamelCase       ,							_UpperCamelCase) else output_size

      UpperCamelCase       ,  UpperCamelCase					       =  get_image_size(_UpperCamelCase)
      UpperCamelCase       ,  UpperCamelCase					       =  output_size

      # determine new height and width
      UpperCamelCase					       =  output_height / input_height
      UpperCamelCase					       =  output_width / input_width

      if keep_aspect_ratio:
            # scale as little as possible
            if abs(1 - scale_width) < abs(1 - scale_height):
                  # fit width
                  UpperCamelCase					       =  scale_width
            else:
                  # fit height
                  UpperCamelCase					       =  scale_height

      UpperCamelCase					       =  constraint_to_multiple_of(scale_height * input_height       ,							multiple=_UpperCamelCase)
      UpperCamelCase					       =  constraint_to_multiple_of(scale_width * input_width       ,							multiple=_UpperCamelCase)

      return (new_height, new_width)





class 					A__     (     __snake_case ):

     '''simple docstring'''






     snake_case__					=					["""pixel_values"""]







     def __init__( self      :    Tuple   ,						_SCREAMING_SNAKE_CASE      :    bool = True   ,						_SCREAMING_SNAKE_CASE      :    Dict[str, int] = None   ,						_SCREAMING_SNAKE_CASE      :    PILImageResampling = PILImageResampling.BILINEAR   ,						_SCREAMING_SNAKE_CASE      :    bool = False   ,						_SCREAMING_SNAKE_CASE      :    int = 1   ,						_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      :    int   ,						):






           """simple docstring"""




           super().__init__(**_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  size if size is not None else {'height': 384, 'width': 384}
           UpperCamelCase					       =  get_size_dict(_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  do_resize
           UpperCamelCase					       =  size
           UpperCamelCase					       =  keep_aspect_ratio
           UpperCamelCase					       =  ensure_multiple_of
           UpperCamelCase					       =  resample
           UpperCamelCase					       =  do_rescale
           UpperCamelCase					       =  rescale_factor
           UpperCamelCase					       =  do_normalize
           UpperCamelCase					       =  image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
           UpperCamelCase					       =  image_std if image_std is not None else IMAGENET_STANDARD_STD







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






           """simple docstring"""




           UpperCamelCase					       =  get_size_dict(_SCREAMING_SNAKE_CASE )
           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					       =  get_resize_output_image_size(
               _SCREAMING_SNAKE_CASE   ,						output_size=(size['height'], size['width'])   ,						keep_aspect_ratio=_SCREAMING_SNAKE_CASE   ,						multiple=_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   _SCREAMING_SNAKE_CASE     ( self      :    Optional[Any]   ,						_SCREAMING_SNAKE_CASE      :    np.ndarray   ,						_SCREAMING_SNAKE_CASE      :    Union[int, float]   ,						_SCREAMING_SNAKE_CASE      :    Optional[Union[str, ChannelDimension]] = None   ,						**_SCREAMING_SNAKE_CASE      :    Any   ,						):






           """simple docstring"""




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







     def   _SCREAMING_SNAKE_CASE     ( 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      :    Optional[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   _SCREAMING_SNAKE_CASE     ( self      :    List[Any]   ,						_SCREAMING_SNAKE_CASE      :    ImageInput   ,						_SCREAMING_SNAKE_CASE      :    bool = None   ,						_SCREAMING_SNAKE_CASE      :    int = None   ,						_SCREAMING_SNAKE_CASE      :    bool = None   ,						_SCREAMING_SNAKE_CASE      :    int = None   ,						_SCREAMING_SNAKE_CASE      :    PILImageResampling = None   ,						_SCREAMING_SNAKE_CASE      :    bool = None   ,						_SCREAMING_SNAKE_CASE      :    float = None   ,						_SCREAMING_SNAKE_CASE      :    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      :    ChannelDimension = ChannelDimension.FIRST   ,						**_SCREAMING_SNAKE_CASE      :    Dict   ,						):






           """simple docstring"""




           UpperCamelCase					       =  do_resize if do_resize is not None else self.do_resize
           UpperCamelCase					       =  size if size is not None else self.size
           UpperCamelCase					       =  get_size_dict(_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
           UpperCamelCase					       =  ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
           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					       =  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 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.' )

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

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

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

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

           UpperCamelCase					       =  [to_channel_dimension_format(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE ) for image in images]

           UpperCamelCase					       =  {'pixel_values': images}
           return BatchFeature(data=_SCREAMING_SNAKE_CASE   ,						tensor_type=_SCREAMING_SNAKE_CASE )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[Any]   ,						_SCREAMING_SNAKE_CASE      :    Any   ,						_SCREAMING_SNAKE_CASE      :    List[Tuple] = None ):






           """simple docstring"""




           UpperCamelCase					       =  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 ):
                       UpperCamelCase					       =  target_sizes.numpy()

                 UpperCamelCase					       =  []

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

           return semantic_segmentation











import torch
from torch import nn





class 					A__     (     nn.Module ):

     '''simple docstring'''






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






           """simple docstring"""




           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(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE ) ) )
                       else:
                             self.out_projs.append(_SCREAMING_SNAKE_CASE )

                 self.out_layers.append(nn.Linear(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE ) )
           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(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE ) ) )

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

           UpperCamelCase					       =  keep_order







     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict   ,						_SCREAMING_SNAKE_CASE      :    Optional[Any]   ,						_SCREAMING_SNAKE_CASE      :    Dict   ,						_SCREAMING_SNAKE_CASE      :    List[Any]   ,						_SCREAMING_SNAKE_CASE      :    Dict ):






           """simple docstring"""




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






           """simple docstring"""




           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(_SCREAMING_SNAKE_CASE   ,						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(_SCREAMING_SNAKE_CASE   ,						dtype=hidden.dtype   ,						device=hidden.device )
                       UpperCamelCase					       =  (
                           -nn.functional.log_softmax(_SCREAMING_SNAKE_CASE   ,						dim=-1 )[mask].gather(1   ,						labels[mask].unsqueeze(1 ) ).squeeze(1 )
                       )
                 else:
                       UpperCamelCase					       =  nn.functional.log_softmax(_SCREAMING_SNAKE_CASE   ,						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(_SCREAMING_SNAKE_CASE )
                       biases.append(_SCREAMING_SNAKE_CASE )

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

                 UpperCamelCase					       =  self._compute_logit(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )
                 UpperCamelCase					       =  nn.functional.log_softmax(_SCREAMING_SNAKE_CASE   ,						dim=1 )

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

                 UpperCamelCase					       =  0
                 UpperCamelCase					       =  [0] + self.cutoffs
                 for i in range(len(_SCREAMING_SNAKE_CASE ) - 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   ,						_SCREAMING_SNAKE_CASE ) - l_idx
                             UpperCamelCase					       =  head_logprob.index_select(0   ,						_SCREAMING_SNAKE_CASE )
                             UpperCamelCase					       =  hidden.index_select(0   ,						_SCREAMING_SNAKE_CASE )
                       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(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )
                             UpperCamelCase					       =  nn.functional.log_softmax(_SCREAMING_SNAKE_CASE   ,						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   ,						_SCREAMING_SNAKE_CASE   ,						-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      :    int   ,						_SCREAMING_SNAKE_CASE      :    str ):






           """simple docstring"""




           if self.n_clusters == 0:
                 UpperCamelCase					       =  self._compute_logit(_SCREAMING_SNAKE_CASE   ,						self.out_layers[0].weight   ,						self.out_layers[0].bias   ,						self.out_projs[0] )
                 return nn.functional.log_softmax(_SCREAMING_SNAKE_CASE   ,						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(_SCREAMING_SNAKE_CASE )
                       biases.append(_SCREAMING_SNAKE_CASE )

                 UpperCamelCase       ,  UpperCamelCase       ,  UpperCamelCase					       =  weights[0], biases[0], self.out_projs[0]
                 UpperCamelCase					       =  self._compute_logit(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )

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

                 UpperCamelCase					       =  [0] + self.cutoffs
                 for i in range(len(_SCREAMING_SNAKE_CASE ) - 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(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )
                             UpperCamelCase					       =  nn.functional.log_softmax(_SCREAMING_SNAKE_CASE   ,						dim=1 )

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

                 return out



