


'''simple docstring'''






import torch
from torch import nn




class 	a       (       nn.Module    ):






 """simple docstring"""




 def __init__(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__=1 ,			__magic_name__=False  )   ->							str:
      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(__magic_name__ ,			__magic_name__  )  )  )
                else:
                     self.out_projs.append(__magic_name__  )

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

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

      _a      =							keep_order
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							List[str]:
      if proj is None:
           _a      =							nn.functional.linear(__magic_name__ ,			__magic_name__ ,			bias=__magic_name__  )
      else:
           # if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
           _a      =							nn.functional.linear(__magic_name__ ,			proj.t().contiguous()  )
           _a      =							nn.functional.linear(__magic_name__ ,			__magic_name__ ,			bias=__magic_name__  )
           # 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 ,			__magic_name__ ,			__magic_name__=None ,			__magic_name__=False  )   ->							List[Any]:

      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(__magic_name__ ,			self.out_layers[0].weight ,			self.out_layers[0].bias ,			self.out_projs[0]  )
           if labels is not None:
                _a      =							labels != -1_00
                _a      =							torch.zeros_like(__magic_name__ ,			dtype=hidden.dtype ,			device=hidden.device  )
                _a      =							(
                    -nn.functional.log_softmax(__magic_name__ ,			dim=-1  )[mask].gather(1 ,			labels[mask].unsqueeze(1  )  ).squeeze(1  )
                )
           else:
                _a      =							nn.functional.log_softmax(__magic_name__ ,			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(__magic_name__  )
                biases.append(__magic_name__  )

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

           _a      =							self._compute_logit(__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )
           _a      =							nn.functional.log_softmax(__magic_name__ ,			dim=1  )

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

           _a      =							0
           _a      =							[0] + self.cutoffs
           for i in range(len(__magic_name__  ) - 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 ,			__magic_name__  ) - l_idx
                     _a      =							head_logprob.index_select(0 ,			__magic_name__  )
                     _a      =							hidden.index_select(0 ,			__magic_name__  )
                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(__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )
                     _a      =							nn.functional.log_softmax(__magic_name__ ,			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 ,			__magic_name__ ,			-logprob_i  )
                     else:
                          out[offset : offset + logprob_i.size(0  )].copy_(-logprob_i  )
                     offset += logprob_i.size(0  )

      return out




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

           _a ,				_a ,				_a      =							weights[0], biases[0], self.out_projs[0]
           _a      =							self._compute_logit(__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )

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

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

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

           return out





'''simple docstring'''






import warnings

from ...utils import logging
from .image_processing_clip import CLIPImageProcessor


a_   :      Optional[Any]				    =      logging.get_logger(__name__)




class 	a       (       _SCREAMING_SNAKE_CASE    ):
 def __init__(	self ,			*__magic_name__ ,			**__magic_name__  )   ->							None:
      warnings.warn(
          'The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
          ' use CLIPImageProcessor instead.' ,			__magic_name__ ,			)
      super().__init__(*__magic_name__ ,			**__magic_name__  )

