class_docstr: This similarity function performs a dot product between a vector of weights and some
  combination of the two input vectors, followed by an (optional) activation function.  The
  combination used is configurable.
  
  If the two vectors are ``x`` and ``y``, we allow the following kinds of combinations: ``x``,
  ``y``, ``x*y``, ``x+y``, ``x-y``, ``x/y``, where each of those binary operations is performed
  elementwise.  You can list as many combinations as you want, comma separated.  For example, you
  might give ``x,y,x*y`` as the ``combination`` parameter to this class.  The computed similarity
  function would then be ``w^T [x; y; x*y] + b``, where ``w`` is a vector of weights, ``b`` is a
  bias parameter, and ``[;]`` is vector concatenation.
  
  Note that if you want a bilinear similarity function with a diagonal weight matrix W, where the
  similarity function is computed as `x * w * y + b` (with `w` the diagonal of `W`), you can
  accomplish that with this class by using "x*y" for `combination`.
  
  Parameters
  ----------
  tensor_1_dim : ``int``
      The dimension of the first tensor, ``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 weight vectors correctly.
  tensor_2_dim : ``int``
      The dimension of the second tensor, ``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 weight vectors correctly.
  combination : ``str``, optional (default="x,y")
      Described above.
  activation : ``Activation``, optional (default=linear (i.e. no activation))
      An activation function applied after the ``w^T * [x;y] + b`` calculation.  Default is no
      activation.
code: def __init__(
      self,
      tensor_1_dim,
      tensor_2_dim,
      combination="x,y",
      activation=None,
  ):
      super(LinearSimilarity, self).__init__()
      self._combination = combination
      combined_dim = util.get_combined_dim(
          combination, [tensor_1_dim, tensor_2_dim]
      )
      self._weight_vector = Parameter(torch.Tensor(combined_dim))
      self._bias = Parameter(torch.Tensor(1))
      self._activation = activation or Activation.by_name("linear")()
      self.reset_parameters()
  
file_path: magnitude/pymagnitude/third_party/allennlp/modules/similarity_functions/linear.py
imports: from __future__ import division
  from __future__ import absolute_import
  import math
  import torch
  from torch.nn.parameter import Parameter
  from allennlp.modules.similarity_functions.similarity_function import SimilarityFunction
  from allennlp.nn import Activation, util
label_desc: Use image node_id 1 to create a new LinearSimilarity object from inherited base classes: SimilarityFunction with example: obj = LinearSimilarity(tensor_1_dim, tensor_2_dim, combination, activation)