



'''simple docstring'''




import torch
from torch import nn







class      _lowerCAmelCase							(      nn.Module			):


 def __init__(self	,				lowercase	,				lowercase	,				lowercase	,				lowercase	,				lowercase=1	,				lowercase=False							):
    super().__init__()

    A_     :						str     =					n_token
    A_     :						Dict     =					d_embed
    A_     :						Any     =					d_proj

    A_     :						List[str]     =					cutoffs + [n_token]
    A_     :						List[str]     =					[0] + self.cutoffs
    A_     :						Union[str, Any]     =					div_val

    A_     :						Optional[Any]     =					self.cutoffs[0]
    A_     :						int     =					len(self.cutoffs							) - 1
    A_     :						List[Any]     =					self.shortlist_size + self.n_clusters

    if self.n_clusters > 0:
       A_     :						List[Any]     =					nn.Parameter(torch.zeros(self.n_clusters	,				self.d_embed							)							)
       A_     :						List[str]     =					nn.Parameter(torch.zeros(self.n_clusters							)							)

    A_     :						List[Any]     =					nn.ModuleList()
    A_     :						Tuple     =					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_     :						Optional[Any]     =					self.cutoff_ends[i], self.cutoff_ends[i + 1]
          A_     :						Union[str, Any]     =					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_     :						Union[str, Any]     =					keep_order


 def    _a     (self	,				lowercase	,				lowercase	,				lowercase	,				lowercase							):
    if proj is None:
       A_     :						Optional[int]     =					nn.functional.linear(lowercase	,				lowercase	,				bias=lowercase							)
    else:
       # if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
       A_     :						Optional[int]     =					nn.functional.linear(lowercase	,				proj.t().contiguous()							)
       A_     :						int     =					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    _a     (self	,				lowercase	,				lowercase=None	,				lowercase=False							):

    if labels is not None:
       # Shift so that tokens < n predict n
       A_     :						Union[str, Any]     =					hidden[..., :-1, :].contiguous()
       A_     :						Tuple     =					labels[..., 1:].contiguous()
       A_     :						List[Any]     =					hidden.view(-1	,				hidden.size(-1							)							)
       A_     :						Any     =					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_     :						Dict     =					hidden.view(-1	,				hidden.size(-1							)							)

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

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

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

       A_     :						Optional[int]     =					weights[0], biases[0], self.out_projs[0]

       A_     :						Any     =					self._compute_logit(lowercase	,				lowercase	,				lowercase	,				lowercase							)
       A_     :						Any     =					nn.functional.log_softmax(lowercase	,				dim=1							)

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

       A_     :						Optional[Any]     =					0
       A_     :						Dict     =					[0] + self.cutoffs
       for i in range(len(lowercase							) - 1							):
          A_     :						List[str]     =					cutoff_values[i], cutoff_values[i + 1]

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

             if indices_i.numel() == 0:
                continue

             A_     :						List[Any]     =					labels.index_select(0	,				lowercase							) - l_idx
             A_     :						List[str]     =					head_logprob.index_select(0	,				lowercase							)
             A_     :						Any     =					hidden.index_select(0	,				lowercase							)
          else:
             A_     :						int     =					hidden

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

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

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

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

       A_     :						Tuple     =					weights[0], biases[0], self.out_projs[0]
       A_     :						List[str]     =					self._compute_logit(lowercase	,				lowercase	,				lowercase	,				lowercase							)

       A_     :						Any     =					hidden.new_empty((head_logit.size(0							), self.n_token)							)
       A_     :						List[Any]     =					nn.functional.log_softmax(lowercase	,				dim=1							)

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

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

             A_     :						Union[str, Any]     =					self._compute_logit(lowercase	,				lowercase	,				lowercase	,				lowercase							)
             A_     :						List[str]     =					nn.functional.log_softmax(lowercase	,				dim=1							)

             A_     :						Dict     =					head_logprob[:, -i] + tail_logprob_i
             A_     :						int     =					logprob_i

       return out




'''simple docstring'''




def      a      (			lowerCamelCase__						,				lowerCamelCase__   ):
			'''simple docstring'''





			if density <= 0:
						raise ValueError("""Impossible fluid density"""   )
			if bulk_modulus <= 0:
						raise ValueError("""Impossible bulk modulus"""   )

			return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
						import doctest

						doctest.testmod()