class_docstr: Local convolution Module wrapping ``lax.conv_general_dilated_local``.
  
  Example usage::
  
    >>> import flax.linen as nn
    >>> import jax, jax.numpy as jnp
  
    >>> # valid padding
    >>> layer = nn.ConvLocal(features=4, kernel_size=(3,), padding='VALID')
    >>> out, variables = layer.init_with_output(jax.random.key(0), jnp.ones((1, 8, 3)))
    >>> jax.tree_map(jnp.shape, variables)
    {'params': {'bias': (6, 4), 'kernel': (6, 9, 4)}}
    >>> out.shape
    (1, 6, 4)
    >>> # circular padding with stride 2
    >>> layer = nn.ConvLocal(features=4, kernel_size=(3, 3), strides=2, padding='CIRCULAR')
    >>> out, variables = layer.init_with_output(jax.random.key(0), jnp.ones((1, 8, 3)))
    >>> jax.tree_map(jnp.shape, variables)
    {'params': {'bias': (1, 4, 4), 'kernel': (1, 4, 27, 4)}}
    >>> out.shape
    (1, 4, 4)
    >>> # apply lower triangle mask
    >>> mask = jnp.tril(jnp.ones((6, 9, 4)))
    >>> layer = nn.ConvLocal(features=4, kernel_size=(3,), mask=mask, padding='VALID')
    >>> variables = layer.init(jax.random.key(0), jnp.ones((1, 8, 3)))
  
  Attributes:
    features: number of convolution filters.
    kernel_size: shape of the convolutional kernel. An integer will be
      interpreted as a tuple of the single integer.
    strides: an integer or a sequence of `n` integers, representing the
      inter-window strides (default: 1).
    padding: either the string ``'SAME'``, the string ``'VALID'``, the string
      ``'CIRCULAR'`` (periodic boundary conditions), or a sequence of ``n`` ``(low,
      high)`` integer pairs that give the padding to apply before and after each
      spatial dimension. A single int is interpreted as applying the same padding
      in all dims and assign a single int in a sequence causes the same padding
      to be used on both sides. ``'CAUSAL'`` padding for a 1D convolution will
      left-pad the convolution axis, resulting in same-sized output.
    input_dilation: an integer or a sequence of ``n`` integers, giving the
      dilation factor to apply in each spatial dimension of ``inputs``
      (default: 1). Convolution with input dilation ``d`` is equivalent to
      transposed convolution with stride ``d``.
    kernel_dilation: an integer or a sequence of ``n`` integers, giving the
      dilation factor to apply in each spatial dimension of the convolution
      kernel (default: 1). Convolution with kernel dilation
      is also known as 'atrous convolution'.
    feature_group_count: integer, default 1. If specified divides the input
      features into groups.
    use_bias: whether to add a bias to the output (default: True).
    mask: Optional mask for the weights during masked convolution. The mask must
          be the same shape as the convolution weight matrix.
    dtype: the dtype of the computation (default: infer from input and params).
    param_dtype: the dtype passed to parameter initializers (default: float32).
    precision: numerical precision of the computation see ``jax.lax.Precision``
      for details.
    kernel_init: initializer for the convolutional kernel.
    bias_init: initializer for the bias.
code: def shared_weights(self) -> bool:
      return False
  
imports: import dataclasses
  from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, Union
  import jax
  import jax.numpy
  import numpy
  from jax import eval_shape, lax
  from jax.core import ShapedArray
  from flax.core import meta
  from flax.linen import initializers
  from flax.linen.dtypes import promote_dtype
  from flax.linen.module import Module, compact
label_desc: Use image node_id 1 for calling the ConvLocal obj's underlying member method code with example usage: obj.shared_weights() and returns: False