class_docstr: Computes attention between a vector and a matrix using a bilinear attention function.  This
  function has a matrix of weights `W` and a bias `b`, and the similarity between the vector
  `x` and the matrix `y` is computed as `x^T W y + b`.
  
  Registered as an `Attention` with name "bilinear".
  
  # Parameters
  
  vector_dim : `int`, required
      The dimension of the vector, `x`, described above.  This is `x.size()[-1]` - the length
      of the vector that will go into the similarity computation.  We need this so we can build
      the weight matrix correctly.
  matrix_dim : `int`, required
      The dimension of the matrix, `y`, described above.  This is `y.size()[-1]` - the length
      of the vector that will go into the similarity computation.  We need this so we can build
      the weight matrix correctly.
  activation : `Activation`, optional (default=`linear`)
      An activation function applied after the `x^T W y + b` calculation.  Default is
      linear, i.e. no activation.
  normalize : `bool`, optional (default=`True`)
      If true, we normalize the computed similarities with a softmax, to return a probability
      distribution for your attention.  If false, this is just computing a similarity score.
code: def _forward_internal(
      self, vector: torch.Tensor, matrix: torch.Tensor
  ) -> torch.Tensor:
      intermediate = vector.mm(self._weight_matrix).unsqueeze(1)
      return self._activation(
          intermediate.bmm(matrix.transpose(1, 2)).squeeze(1)
          + self._bias
      )
  
file_path: allennlp/allennlp/modules/attention/bilinear_attention.py
imports: import torch
  from torch.nn.parameter import Parameter
  from allennlp.modules.attention.attention import Attention
  from allennlp.nn import Activation
label_desc: Use image node_id 3 for calling the BilinearAttention obj's underlying member method code with example usage: obj._forward_internal(vector, matrix) and returns: self