class_docstr: Equivariant Graph Convolutional Layer from `E(n) Equivariant Graph
  Neural Networks <https://arxiv.org/abs/2102.09844>`__
  
  .. math::
  
      m_{ij}=\phi_e(h_i^l, h_j^l, ||x_i^l-x_j^l||^2, a_{ij})
  
      x_i^{l+1} = x_i^l + C\sum_{j\in\mathcal{N}(i)}(x_i^l-x_j^l)\phi_x(m_{ij})
  
      m_i = \sum_{j\in\mathcal{N}(i)} m_{ij}
  
      h_i^{l+1} = \phi_h(h_i^l, m_i)
  
  where :math:`h_i`, :math:`x_i`, :math:`a_{ij}` are node features, coordinate
  features, and edge features respectively. :math:`\phi_e`, :math:`\phi_h`, and
  :math:`\phi_x` are two-layer MLPs. :math:`C` is a constant for normalization,
  computed as :math:`1/|\mathcal{N}(i)|`.
  
  Parameters
  ----------
  in_size : int
      Input feature size; i.e. the size of :math:`h_i^l`.
  hidden_size : int
      Hidden feature size; i.e. the size of hidden layer in the two-layer MLPs in
      :math:`\phi_e, \phi_x, \phi_h`.
  out_size : int
      Output feature size; i.e. the size of :math:`h_i^{l+1}`.
  edge_feat_size : int, optional
      Edge feature size; i.e. the size of :math:`a_{ij}`. Default: 0.
  
  Example
  -------
  >>> import dgl
  >>> import torch as th
  >>> from dgl.nn import EGNNConv
  >>>
  >>> g = dgl.graph(([0,1,2,3,2,5], [1,2,3,4,0,3]))
  >>> node_feat, coord_feat, edge_feat = th.ones(6, 10), th.ones(6, 3), th.ones(6, 2)
  >>> conv = EGNNConv(10, 10, 10, 2)
  >>> h, x = conv(g, node_feat, coord_feat, edge_feat)
code: def __init__(self, in_size, hidden_size, out_size, edge_feat_size=0):
      super(EGNNConv, self).__init__()
  
      self.in_size = in_size
      self.hidden_size = hidden_size
      self.out_size = out_size
      self.edge_feat_size = edge_feat_size
      act_fn = nn.SiLU()
  
      # \phi_e
      self.edge_mlp = nn.Sequential(
          # +1 for the radial feature: ||x_i - x_j||^2
          nn.Linear(in_size * 2 + edge_feat_size + 1, hidden_size),
          act_fn,
          nn.Linear(hidden_size, hidden_size),
          act_fn,
      )
  
      # \phi_h
      self.node_mlp = nn.Sequential(
          nn.Linear(in_size + hidden_size, hidden_size),
          act_fn,
          nn.Linear(hidden_size, out_size),
      )
  
      # \phi_x
      self.coord_mlp = nn.Sequential(
          nn.Linear(hidden_size, hidden_size),
          act_fn,
          nn.Linear(hidden_size, 1, bias=False),
      )
  
file_path: dgl/python/dgl/nn/pytorch/conv/egnnconv.py
imports: import torch
  import torch.nn
  from ....None import function
label_desc: Use image node_id 1 to create a new EGNNConv object from inherited base classes: nn with example: obj = EGNNConv(in_size, hidden_size, out_size, edge_feat_size)