class_docstr: Relational graph convolution layer.
  
  Parameters
  ----------
  in_feat : int
      Input feature size.
  out_feat : int
      Output feature size.
  rel_names : list[str]
      Relation names.
  num_bases : int, optional
      Number of bases. If is none, use number of relations. Default: None.
  weight : bool, optional
      True if a linear layer is applied after message passing. Default: True
  bias : bool, optional
      True if bias is added. Default: True
  activation : callable, optional
      Activation function. Default: None
  self_loop : bool, optional
      True to include self loop message. Default: False
  dropout : float, optional
      Dropout rate. Default: 0.0
docstr: Forward computation
  
  Parameters
  ----------
  g : DGLGraph
      Input graph.
  inputs : dict[str, torch.Tensor]
      Node feature for each node type.
  
  Returns
  -------
  dict[str, torch.Tensor]
      New node features for each node type.
docstr_tok: ["Forward","computation","Parameters","--","--","--","--","--","g",":","DGLGraph","Input","graph",".","inputs",":","dict","[","str",",","torch.Tensor","]","Node","feature","for","each","node","type",".","Returns","--","--","--","-","dict","[","str",",","torch.Tensor","]","New","node","features","for","each","node","type","."]
code: def forward(self, g, inputs):
      """Forward computation
  
      Parameters
      ----------
      g : DGLGraph
          Input graph.
      inputs : dict[str, torch.Tensor]
          Node feature for each node type.
  
      Returns
      -------
      dict[str, torch.Tensor]
          New node features for each node type.
      """
      g = g.local_var()
      if self.use_weight:
          weight = self.basis() if self.use_basis else self.weight
          wdict = {
              self.rel_names[i]: {"weight": w.squeeze(0)}
              for i, w in enumerate(th.split(weight, 1, dim=0))
          }
      else:
          wdict = {}
  
      if g.is_block:
          inputs_src = inputs
          inputs_dst = {
              k: v[: g.number_of_dst_nodes(k)]
              for k, v in inputs.items()
          }
      else:
          inputs_src = inputs_dst = inputs
  
      hs = self.conv(g, inputs, mod_kwargs=wdict)
  
      def _apply(ntype, h):
          if self.self_loop:
              h = h + th.matmul(inputs_dst[ntype], self.loop_weight)
          if self.bias:
              h = h + self.h_bias
          if self.activation:
              h = self.activation(h)
          return self.dropout(h)
  
      return {ntype: _apply(ntype, h) for ntype, h in hs.items()}
  
imports: import itertools
  import time
  import traceback
  import dgl
  import dgl.nn.pytorch
  import torch
  import torch.multiprocessing
  import torch.nn
  import torch.nn.functional
  import torch.optim
  from torch.utils.data import DataLoader
  from ..None import utils
label_desc: Use image node_id 2 for calling the RelGraphConvLayer obj's underlying member method code with example usage: obj.forward(g, inputs) and returns: unknown, self