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)
docstr: message function for EGNN
docstr_tok: ["message","function","for","EGNN"]
code: def message(self, edges):
      """message function for EGNN"""
      # concat features for edge mlp
      if self.edge_feat_size > 0:
          f = torch.cat(
              [
                  edges.src["h"],
                  edges.dst["h"],
                  edges.data["radial"],
                  edges.data["a"],
              ],
              dim=-1,
          )
      else:
          f = torch.cat(
              [edges.src["h"], edges.dst["h"], edges.data["radial"]],
              dim=-1,
          )
  
      msg_h = self.edge_mlp(f)
      msg_x = self.coord_mlp(msg_h) * edges.data["x_diff"]
  
      return {"msg_x": msg_x, "msg_h": msg_h}
  
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 2 for calling the EGNNConv obj's underlying member method code with example usage: obj.message(edges) and returns: dict