class_docstr: A layer that uses `einsum` as the backing computation.
  
  This layer can perform einsum calculations of arbitrary dimensionality.
  
  Args:
      equation: An equation describing the einsum to perform.
          This equation must be a valid einsum string of the form
          `ab,bc->ac`, `...ab,bc->...ac`, or
          `ab...,bc->ac...` where 'ab', 'bc', and 'ac' can be any valid einsum
          axis expression sequence.
      output_shape: The expected shape of the output tensor
          (excluding the batch dimension and any dimensions
          represented by ellipses). You can specify `None` for any dimension
          that is unknown or can be inferred from the input shape.
      activation: Activation function to use. If you don't specify anything,
          no activation is applied
          (that is, a "linear" activation: `a(x) = x`).
      bias_axes: A string containing the output dimension(s)
          to apply a bias to. Each character in the `bias_axes` string
          should correspond to a character in the output portion
          of the `equation` string.
      kernel_initializer: Initializer for the `kernel` weights matrix.
      bias_initializer: Initializer for the bias vector.
      kernel_regularizer: Regularizer function applied to the `kernel` weights
          matrix.
      bias_regularizer: Regularizer function applied to the bias vector.
      kernel_constraint: Constraint function applied to the `kernel` weights
          matrix.
      bias_constraint: Constraint function applied to the bias vector.
      lora_rank: Optional integer. If set, the layer's forward pass
          will implement LoRA (Low-Rank Adaptation)
          with the provided rank. LoRA sets the layer's kernel
          to non-trainable and replaces it with a delta over the
          original kernel, obtained via multiplying two lower-rank
          trainable matrices
          (the factorization happens on the last dimension).
          This can be useful to reduce the
          computation cost of fine-tuning large dense layers.
          You can also enable LoRA on an existing
          `EinsumDense` layer by calling `layer.enable_lora(rank)`.
      **kwargs: Base layer keyword arguments, such as `name` and `dtype`.
  
  Examples:
  
  **Biased dense layer with einsums**
  
  This example shows how to instantiate a standard Keras dense layer using
  einsum operations. This example is equivalent to
  `keras.layers.Dense(64, use_bias=True)`.
  
  >>> layer = keras.layers.EinsumDense("ab,bc->ac",
  ...                                       output_shape=64,
  ...                                       bias_axes="c")
  >>> input_tensor = keras.Input(shape=[32])
  >>> output_tensor = layer(input_tensor)
  >>> output_tensor.shape
  (None, 64)
  
  **Applying a dense layer to a sequence**
  
  This example shows how to instantiate a layer that applies the same dense
  operation to every element in a sequence. Here, the `output_shape` has two
  values (since there are two non-batch dimensions in the output); the first
  dimension in the `output_shape` is `None`, because the sequence dimension
  `b` has an unknown shape.
  
  >>> layer = keras.layers.EinsumDense("abc,cd->abd",
  ...                                       output_shape=(None, 64),
  ...                                       bias_axes="d")
  >>> input_tensor = keras.Input(shape=[32, 128])
  >>> output_tensor = layer(input_tensor)
  >>> output_tensor.shape
  (None, 32, 64)
  
  **Applying a dense layer to a sequence using ellipses**
  
  This example shows how to instantiate a layer that applies the same dense
  operation to every element in a sequence, but uses the ellipsis notation
  instead of specifying the batch and sequence dimensions.
  
  Because we are using ellipsis notation and have specified only one axis, the
  `output_shape` arg is a single value. When instantiated in this way, the
  layer can handle any number of sequence dimensions - including the case
  where no sequence dimension exists.
  
  >>> layer = keras.layers.EinsumDense("...x,xy->...y",
  ...                                       output_shape=64,
  ...                                       bias_axes="y")
  >>> input_tensor = keras.Input(shape=[32, 128])
  >>> output_tensor = layer(input_tensor)
  >>> output_tensor.shape
  (None, 32, 64)
code: def build(self, input_shape):
      shape_data = _analyze_einsum_string(
          self.equation,
          self.bias_axes,
          input_shape,
          self.partial_output_shape,
      )
      kernel_shape, bias_shape, full_output_shape = shape_data
      self.full_output_shape = tuple(full_output_shape)
      self._kernel = self.add_weight(
          name="kernel",
          shape=tuple(kernel_shape),
          initializer=self.kernel_initializer,
          regularizer=self.kernel_regularizer,
          constraint=self.kernel_constraint,
          dtype=self.dtype,
          trainable=True,
      )
  
      if bias_shape is not None:
          self.bias = self.add_weight(
              name="bias",
              shape=tuple(bias_shape),
              initializer=self.bias_initializer,
              regularizer=self.bias_regularizer,
              constraint=self.bias_constraint,
              dtype=self.dtype,
              trainable=True,
          )
      else:
          self.bias = None
      super().build(input_shape)
      if self.lora_rank:
          self.enable_lora(self.lora_rank)
  
imports: import re
  import numpy
  from keras import activations
  from keras import constraints
  from keras import initializers
  from keras import ops
  from keras import regularizers
  from keras.api_export import keras_export
  from keras.layers.layer import Layer
label_desc: Use image node_id 2 for calling the EinsumDense obj's underlying member method code with example usage: obj.build(input_shape) without return types