class_docstr: Chebyshev Spectral Graph Convolution layer from `Convolutional Neural Networks on Graphs
  with Fast Localized Spectral Filtering <https://arxiv.org/pdf/1606.09375.pdf>`__
  
  .. math::
      h_i^{l+1} &= \sum_{k=0}^{K-1} W^{k, l}z_i^{k, l}
  
      Z^{0, l} &= H^{l}
  
      Z^{1, l} &= \tilde{L} \cdot H^{l}
  
      Z^{k, l} &= 2 \cdot \tilde{L} \cdot Z^{k-1, l} - Z^{k-2, l}
  
      \tilde{L} &= 2\left(I - \tilde{D}^{-1/2} \tilde{A} \tilde{D}^{-1/2}\right)/\lambda_{max} - I
  
  where :math:`\tilde{A}` is :math:`A` + :math:`I`, :math:`W` is learnable weight.
  
  
  Parameters
  ----------
  in_feats: int
      Dimension of input features; i.e, the number of dimensions of :math:`h_i^{(l)}`.
  out_feats: int
      Dimension of output features :math:`h_i^{(l+1)}`.
  k : int
      Chebyshev filter size :math:`K`.
  activation : function, optional
      Activation function. Default ``ReLu``.
  bias : bool, optional
      If True, adds a learnable bias to the output. Default: ``True``.
  
  Example
  -------
  >>> import dgl
  >>> import numpy as np
  >>> import mxnet as mx
  >>> from dgl.nn import ChebConv
  >>> g = dgl.graph(([0,1,2,3,2,5], [1,2,3,4,0,3]))
  >>> feat = mx.nd.ones((6, 10))
  >>> conv = ChebConv(10, 2, 2)
  >>> conv.initialize(ctx=mx.cpu(0))
  >>> res = conv(g, feat)
  >>> res
  [[ 0.832592   -0.738757  ]
  [ 0.832592   -0.738757  ]
  [ 0.832592   -0.738757  ]
  [ 0.43377423 -1.0455742 ]
  [ 1.1145986  -0.5218046 ]
  [ 1.7954229   0.00196505]]
  <NDArray 6x2 @cpu(0)>
code: def __init__(self, in_feats, out_feats, k, bias=True):
      super(ChebConv, self).__init__()
      self._in_feats = in_feats
      self._out_feats = out_feats
      self._k = k
      with self.name_scope():
          self.fc = nn.Sequential()
          for _ in range(k):
              self.fc.add(
                  nn.Dense(
                      out_feats,
                      use_bias=False,
                      weight_initializer=mx.init.Xavier(
                          magnitude=math.sqrt(2.0)
                      ),
                      in_units=in_feats,
                  )
              )
          if bias:
              self.bias = self.params.get(
                  "bias", shape=(out_feats,), init=mx.init.Zero()
              )
          else:
              self.bias = None
  
file_path: dgl/python/dgl/nn/mxnet/conv/chebconv.py
imports: import math
  import mxnet
  from mxnet import nd
  from mxnet.gluon import nn
  from ....None import broadcast_nodes, function
  from ....base import dgl_warning
label_desc: Use image node_id 1 to create a new ChebConv object from inherited base classes: nn with example: obj = ChebConv(in_feats, out_feats, k, bias)