code: def forward(self, g, feats):
      with g.local_scope():
          init_feats = feats
          # assume that the graphs are undirected and graph.in_degrees() is the same as graph.out_degrees()
          degs = g.in_degrees().float().clamp(min=1)
          norm = torch.pow(degs, -0.5).to(feats.device).unsqueeze(1)
          output = None
  
          for k in range(self.K):
              feats = init_feats
              for t in range(self.T):
                  feats = feats * norm
                  g.ndata["h"] = feats
                  g.update_all(fn.copy_u("h", "m"), fn.sum("m", "h"))
                  feats = g.ndata.pop("h")
                  feats = feats * norm
  
                  if t == 0:
                      feats = self.w_0[str(k)](feats)
                  else:
                      feats = self.w[str(k)](feats)
  
                  feats += self.dropout(self.v[str(k)](init_feats))
                  feats += self.v[str(k)](self.dropout(init_feats))
  
                  if self.bias is not None:
                      feats += self.bias[k][t]
  
                  if self.activation is not None:
                      feats = self.activation(feats)
  
              if output is None:
                  output = feats
              else:
                  output += feats
  
          return output / self.K
  
imports: import torch
  from torch import nn
  import torch.nn.functional
  import dgl
  from dgl.nn.pytorch.conv import *
  import dgl.function
  import math
  from dgl.utils import expand_as_pair
  from dgl.nn.functional import edge_softmax
  from torch.nn import Parameter
  import torch
  from torch import Tensor
  from ..scatter_utils import *
  from typing import Optional, Tuple, Union
label_desc: Use image node_id 3 for calling the ARMAConv obj's underlying member method code with example usage: obj.forward(g, feats) and returns: unknown