code: def AtomicConvolutionLayer(
      X, Nbrs, Nbrs_Z, atom_types, radial_params, boxsize, B, N, M, d
  ):
      """Atomic convoluation layer
  
      N = max_num_atoms, M = max_num_neighbors, B = batch_size, d = num_features
      l = num_radial_filters * num_atom_types
  
      Parameters
      ----------
      X: tf.Tensor of shape (B, N, d)
        Coordinates/features.
      Nbrs: tf.Tensor of shape (B, N, M)
        Neighbor list.
      Nbrs_Z: tf.Tensor of shape (B, N, M)
        Atomic numbers of neighbor atoms.
      atom_types: list or None
        Of length a, where a is number of atom types for filtering.
      radial_params: list
        Of length l, where l is number of radial filters learned.
      boxsize: float or None
        Simulation box length [Angstrom].
      N: int
        Maximum number of atoms
      M: int
        Maximum number of neighbors
      d: int
        Number of coordinates/features/filters
  
      Returns
      -------
      layer: tf.Tensor of shape (l, B, N)
        A new tensor representing the output of the atomic conv layer
  
      """
  
      D = DistanceTensor(X, Nbrs, boxsize, B, N, M, d)
      R = DistanceMatrix(D)
      sym = []
      rsf_zeros = tf.zeros((B, N, M))
      for param in radial_params:
          # We apply the radial pooling filter before atom type conv
          # to reduce computation
          rsf = RadialSymmetryFunction(R, *param)
  
          if not atom_types:
              cond = tf.not_equal(Nbrs_Z, 0.0)
              sym.append(
                  tf.reduce_sum(tf.where(cond, rsf, rsf_zeros), 2)
              )
          else:
              for j in range(len(atom_types)):
                  cond = tf.equal(Nbrs_Z, atom_types[j])
                  sym.append(
                      tf.reduce_sum(tf.where(cond, rsf, rsf_zeros), 2)
                  )
  
      layer = tf.stack(sym)
      layer = tf.transpose(layer, [1, 2, 0])
      m, v = tf.nn.moments(layer, axes=[0])
      layer = tf.nn.batch_normalization(layer, m, v, None, None, 1e-3)
      return layer
  
file_path: deepchem/contrib/atomicconv/models/atomicnet_ops.py
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import unicode_literals
  import numpy
  import tensorflow
label_desc: Use image node_id 9 for calling a global function with example usage: AtomicConvolutionLayer(X, Nbrs, Nbrs_Z, atom_types, radial_params, boxsize, B, N, M, d) and returns: layer