class_docstr: The chebyshev spectral graph convolutional operator with attention from the
  `Attention Based Spatial-Temporal Graph Convolutional
  Networks for Traffic Flow Forecasting." <https://ojs.aaai.org/index.php/AAAI/article/view/3881>`_ paper
  :math:`\mathbf{\hat{L}}` denotes the scaled and normalized Laplacian
  :math:`\frac{2\mathbf{L}}{\lambda_{\max}} - \mathbf{I}`.
  
  Args:
      in_channels (int): Size of each input sample.
      out_channels (int): Size of each output sample.
      K (int): Chebyshev filter size :math:`K`.
      normalization (str, optional): The normalization scheme for the graph
          Laplacian (default: :obj:`"sym"`):
          1. :obj:`None`: No normalization
          :math:`\mathbf{L} = \mathbf{D} - \mathbf{A}`
          2. :obj:`"sym"`: Symmetric normalization
          :math:`\mathbf{L} = \mathbf{I} - \mathbf{D}^{-1/2} \mathbf{A}
          \mathbf{D}^{-1/2}`
          3. :obj:`"rw"`: Random-walk normalization
          :math:`\mathbf{L} = \mathbf{I} - \mathbf{D}^{-1} \mathbf{A}`
          You need to pass :obj:`lambda_max` to the :meth:`forward` method of
          this operator in case the normalization is non-symmetric.
          :obj:`\lambda_max` should be a :class:`torch.Tensor` of size
          :obj:`[num_graphs]` in a mini-batch scenario and a
          scalar/zero-dimensional tensor when operating on single graphs.
          You can pre-compute :obj:`lambda_max` via the
          :class:`torch_geometric.transforms.LaplacianLambdaMax` transform.
      bias (bool, optional): If set to :obj:`False`, the layer will not learn
          an additive bias. (default: :obj:`True`)
      **kwargs (optional): Additional arguments of
          :class:`torch_geometric.nn.conv.MessagePassing`.
code: def __init__(
      self,
      in_channels: int,
      out_channels: int,
      K: int,
      normalization: Optional[str] = None,
      bias: bool = True,
      **kwargs,
  ):
      kwargs.setdefault("aggr", "add")
      super(ChebConvAttention, self).__init__(**kwargs)
  
      assert K > 0
      assert normalization in [
          None,
          "sym",
          "rw",
      ], "Invalid normalization"
  
      self._in_channels = in_channels
      self._out_channels = out_channels
      self._normalization = normalization
      self._weight = Parameter(
          torch.Tensor(K, in_channels, out_channels)
      )
  
      if bias:
          self._bias = Parameter(torch.Tensor(out_channels))
      else:
          self.register_parameter("_bias", None)
  
      self._reset_parameters()
  
imports: import math
  from typing import Optional, List, Union
  import torch
  import torch.nn
  from torch.nn import Parameter
  import torch.nn.functional
  from torch_geometric.data import Data
  from torch_geometric.typing import OptTensor
  from torch_geometric.nn.conv import MessagePassing
  from torch_geometric.transforms import LaplacianLambdaMax
  from torch_geometric.utils import remove_self_loops, add_self_loops, get_laplacian
label_desc: Use image node_id 1 to create a new ChebConvAttention object from inherited base classes: MessagePassing with example: obj = ChebConvAttention(in_channels, out_channels, K, normalization, bias)