code: def conv(
      scope,
      inputs,
      features,
      kernel_size,
      strides=None,
      padding="SAME",
      input_dilation=None,
      kernel_dilation=None,
      feature_group_count=1,
      bias=True,
      dtype=jnp.float32,
      precision=None,
      kernel_init=default_kernel_init,
      bias_init=initializers.zeros_init(),
  ):
      """Applies a convolution to the inputs.
  
      Args:
        inputs: input data with dimensions (batch, spatial_dims..., features).
        features: number of convolution filters.
        kernel_size: shape of the convolutional kernel.
        strides: a sequence of `n` integers, representing the inter-window
          strides.
        padding: either the string `'SAME'`, the string `'VALID'`, or a sequence
          of `n` `(low, high)` integer pairs that give the padding to apply before
          and after each spatial dimension.
        input_dilation: `None`, or a sequence of `n` integers, giving the
          dilation factor to apply in each spatial dimension of `inputs`.
          Convolution with input dilation `d` is equivalent to transposed
          convolution with stride `d`.
        kernel_dilation: `None`, or a sequence of `n` integers, giving the
          dilation factor to apply in each spatial dimension of the convolution
          kernel. Convolution with kernel dilation is also known as 'atrous
          convolution'.
        feature_group_count: integer, default 1. If specified divides the input
          features into groups.
        bias: whether to add a bias to the output (default: True).
        dtype: the dtype of the computation (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.
      Returns:
        The convolved data.
      """
  
      inputs = jnp.asarray(inputs, dtype)
  
      if strides is None:
          strides = (1,) * (inputs.ndim - 2)
  
      in_features = inputs.shape[-1]
      assert in_features % feature_group_count == 0
      kernel_shape = kernel_size + (
          in_features // feature_group_count,
          features,
      )
      kernel = scope.param("kernel", kernel_init, kernel_shape)
      kernel = jnp.asarray(kernel, dtype)
  
      dimension_numbers = _conv_dimension_numbers(inputs.shape)
      y = lax.conv_general_dilated(
          inputs,
          kernel,
          strides,
          padding,
          lhs_dilation=input_dilation,
          rhs_dilation=kernel_dilation,
          dimension_numbers=dimension_numbers,
          feature_group_count=feature_group_count,
          precision=precision,
      )
  
      if bias:
          bias = scope.param("bias", bias_init, (features,))
          bias = jnp.asarray(bias, dtype)
          y += jnp.reshape(bias, (1,) * (y.ndim - 1) + (-1,))
      return y
  
file_path: flax/flax/core/nn/linear.py
imports: from collections.abc import Iterable
  import jax.numpy
  import numpy
  from jax import lax
  from flax import struct
  from flax.core import Scope
  from flax.linen import initializers
label_desc: Use image node_id 5 for calling a global function with example usage: conv(scope, inputs, features, kernel_size, strides, padding, input_dilation, kernel_dilation, feature_group_count, bias, dtype, precision, kernel_init, bias_init) and returns: y