

import torch
from torch import nn

class        a__    (       nn.Module      ):
			"""simple docstring"""







			def __init__(     self   ,   lowercase   ,   lowercase   ,   lowercase   ,   lowercase   ,   lowercase=1   ,   lowercase=False							)	->    Optional[Any]:
							'''simple docstring'''






							super().__init__()

							A__          =      n_token
							A__          =      d_embed
							A__          =      d_proj

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

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

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

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


			def   UpperCamelCase		(     self   ,   lowercase   ,   lowercase   ,   lowercase   ,   lowercase							)	->    Optional[int]:
							'''simple docstring'''






							if proj is None:
											A__          =      nn.functional.linear(lowercase   ,   lowercase   ,   bias=lowercase							)
							else:
											# if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
											A__          =      nn.functional.linear(lowercase   ,   proj.t().contiguous()							)
											A__          =      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   UpperCamelCase		(     self   ,   lowercase   ,   lowercase=None   ,   lowercase=False							)	->    List[Any]:
							'''simple docstring'''






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

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

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

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

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

											A__          =      self._compute_logit(lowercase   ,   lowercase   ,   lowercase   ,   lowercase							)
											A__          =      nn.functional.log_softmax(lowercase   ,   dim=1							)

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

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

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

																			if indices_i.numel() == 0:
																							continue

																			A__          =      labels.index_select(0   ,   lowercase							) - l_idx
																			A__          =      head_logprob.index_select(0   ,   lowercase							)
																			A__          =      hidden.index_select(0   ,   lowercase							)
															else:
																			A__          =      hidden

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

																			A__          =      self._compute_logit(lowercase   ,   lowercase   ,   lowercase   ,   lowercase							)
																			A__          =      nn.functional.log_softmax(lowercase   ,   dim=1							)
																			A__          =      self.cutoffs[0] + i - 1  # No probability for the head cluster
																			if labels is not None:
																							A__          =      head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather(
																							    1   ,   target_i[:, None]							).squeeze(1							)
																			else:
																							A__          =      head_logprob[:, cluster_prob_idx, None] + tail_logprob_i
																							A__          =      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   UpperCamelCase		(     self   ,   lowercase							)	->    Any:
							'''simple docstring'''






							if self.n_clusters == 0:
											A__          =      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__          =      [], []
											for i in range(len(self.cutoffs							)							):
															if self.div_val == 1:
																			A__     ,					A__          =      self.cutoff_ends[i], self.cutoff_ends[i + 1]
																			A__          =      self.out_layers[0].weight[l_idx:r_idx]
																			A__          =      self.out_layers[0].bias[l_idx:r_idx]
															else:
																			A__          =      self.out_layers[i].weight
																			A__          =      self.out_layers[i].bias

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

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

											A__     ,					A__     ,					A__          =      weights[0], biases[0], self.out_projs[0]
											A__          =      self._compute_logit(lowercase   ,   lowercase   ,   lowercase   ,   lowercase							)

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

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

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

																			A__          =      self._compute_logit(lowercase   ,   lowercase   ,   lowercase   ,   lowercase							)
																			A__          =      nn.functional.log_softmax(lowercase   ,   dim=1							)

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

											return out


"""simple docstring"""



from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

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,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
   import PIL

SCREAMING_SNAKE_CASE__:Tuple									=			logging.get_logger(__name__)



def 	_lowerCamelCase(	a				):
       if isinstance(a   ,    (list, tuple)				) and isinstance(videos[0]   ,    (list, tuple)				) and is_valid_image(videos[0][0]				):
              return videos

       elif isinstance(a   ,    (list, tuple)				) and is_valid_image(videos[0]				):
              return [videos]

       elif is_valid_image(a				):
              return [[videos]]

       raise ValueError(F"Could not make batched video from {videos}"				)






class  snake_case__      (       snake_case_       ):
 _snake_case       :					List[Any]							  =						["""pixel_values"""]


 def __init__( self    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		lowerCamelCase = PILImageResampling.BILINEAR    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		lowerCamelCase = True    ,		lowerCamelCase = 1 / 255    ,		lowerCamelCase = True    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        super().__init__(**lowerCamelCase						)
        __a       =    size if size is not None else {"shortest_edge": 256}
        __a       =    get_size_dict(lowerCamelCase    ,		default_to_square=lowerCamelCase						)
        __a       =    crop_size if crop_size is not None else {"height": 224, "width": 224}
        __a       =    get_size_dict(lowerCamelCase    ,		param_name="crop_size"						)

        __a       =    do_resize
        __a       =    size
        __a       =    do_center_crop
        __a       =    crop_size
        __a       =    resample
        __a       =    do_rescale
        __a       =    rescale_factor
        __a       =    offset
        __a       =    do_normalize
        __a       =    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        __a       =    image_std if image_std is not None else IMAGENET_STANDARD_STD


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = PILImageResampling.BILINEAR    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        __a       =    get_size_dict(lowerCamelCase    ,		default_to_square=lowerCamelCase						)
        if "shortest_edge" in size:
               __a       =    get_resize_output_image_size(lowerCamelCase    ,		size["shortest_edge"]    ,		default_to_square=lowerCamelCase						)
        elif "height" in size and "width" in size:
               __a       =    (size["height"], size["width"])
        else:
               raise ValueError(F"Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"						)
        return resize(lowerCamelCase    ,		size=lowerCamelCase    ,		resample=lowerCamelCase    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        __a       =    get_size_dict(lowerCamelCase						)
        if "height" not in size or "width" not in size:
               raise ValueError(F"Size must have 'height' and 'width' as keys. Got {size.keys()}"						)
        return center_crop(lowerCamelCase    ,		size=(size["height"], size["width"])    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        __a       =    image.astype(np.floataa						)
        if offset:
               __a       =    image - (scale / 2)
        return rescale(lowerCamelCase    ,		scale=lowerCamelCase    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        return normalize(lowerCamelCase    ,		mean=lowerCamelCase    ,		std=lowerCamelCase    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( 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    ,		):
        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_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."						)

        if offset and not do_rescale:
               raise ValueError("For offset, do_rescale must also be set to True."						)

        # All transformations expect numpy arrays.
        __a       =    to_numpy_array(lowerCamelCase						)

        if do_resize:
               __a       =    self.resize(image=lowerCamelCase    ,		size=lowerCamelCase    ,		resample=lowerCamelCase						)

        if do_center_crop:
               __a       =    self.center_crop(lowerCamelCase    ,		size=lowerCamelCase						)

        if do_rescale:
               __a       =    self.rescale(image=lowerCamelCase    ,		scale=lowerCamelCase    ,		offset=lowerCamelCase						)

        if do_normalize:
               __a       =    self.normalize(image=lowerCamelCase    ,		mean=lowerCamelCase    ,		std=lowerCamelCase						)

        __a       =    to_channel_dimension_format(lowerCamelCase    ,		lowerCamelCase						)
        return image






 def 						a__   ( 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 = None    ,		lowerCamelCase = ChannelDimension.FIRST    ,		**lowerCamelCase    ,		):
        __a       =    do_resize if do_resize is not None else self.do_resize
        __a       =    resample if resample is not None else self.resample
        __a       =    do_center_crop if do_center_crop is not None else self.do_center_crop
        __a       =    do_rescale if do_rescale is not None else self.do_rescale
        __a       =    rescale_factor if rescale_factor is not None else self.rescale_factor
        __a       =    offset if offset is not None else self.offset
        __a       =    do_normalize if do_normalize is not None else self.do_normalize
        __a       =    image_mean if image_mean is not None else self.image_mean
        __a       =    image_std if image_std is not None else self.image_std

        __a       =    size if size is not None else self.size
        __a       =    get_size_dict(lowerCamelCase    ,		default_to_square=lowerCamelCase						)
        __a       =    crop_size if crop_size is not None else self.crop_size
        __a       =    get_size_dict(lowerCamelCase    ,		param_name="crop_size"						)

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

        __a       =    make_batched(lowerCamelCase						)

        __a       =    [
            [
                self._preprocess_image(
                    image=lowerCamelCase    ,		do_resize=lowerCamelCase    ,		size=lowerCamelCase    ,		resample=lowerCamelCase    ,		do_center_crop=lowerCamelCase    ,		crop_size=lowerCamelCase    ,		do_rescale=lowerCamelCase    ,		rescale_factor=lowerCamelCase    ,		offset=lowerCamelCase    ,		do_normalize=lowerCamelCase    ,		image_mean=lowerCamelCase    ,		image_std=lowerCamelCase    ,		data_format=lowerCamelCase    ,		)
                for img in video
            ]
            for video in videos
        ]

        __a       =    {"pixel_values": videos}
        return BatchFeature(data=lowerCamelCase    ,		tensor_type=lowerCamelCase						)
