class_docstr: An accelerated GraphSAGE layer from `Inductive Representation Learning
  on Large Graphs <https://arxiv.org/pdf/1706.02216.pdf>`, with the sparse
  aggregation accelerated by cugraph-ops.
  
  Parameters
  ----------
  in_feats : int or tuple
      Input feature size. If a scalar is given, the source and destination
      nodes are required to be the same.
  out_feats : int
      Output feature size.
  aggregator_type : str
      Aggregator type to use ("mean", "sum", "min", "max", "pool", "gcn").
  feat_drop : float
      Dropout rate on features, default: ``0``.
  bias : bool
      If True, adds a learnable bias to the output. Default: ``True``.
  
  Examples
  --------
  >>> import dgl
  >>> import torch
  >>> from cugraph_dgl.nn import SAGEConv
  ...
  >>> device = 'cuda'
  >>> g = dgl.graph(([0,1,2,3,2,5], [1,2,3,4,0,3])).to(device)
  >>> g = dgl.add_self_loop(g)
  >>> feat = torch.ones(6, 10).to(device)
  >>> conv = SAGEConv(10, 2, 'mean').to(device)
  >>> res = conv(g, feat)
  >>> res
  tensor([[-1.1690,  0.1952],
          [-1.1690,  0.1952],
          [-1.1690,  0.1952],
          [-1.1690,  0.1952],
          [-1.1690,  0.1952],
          [-1.1690,  0.1952]], device='cuda:0', grad_fn=<AddmmBackward0>)
docstr: Forward computation.
  
  Parameters
  ----------
  g : DGLGraph or SparseGraph
      The graph.
  feat : torch.Tensor or tuple
      Node features. Shape: :math:`(|V|, D_{in})`.
  max_in_degree : int
      Maximum in-degree of destination nodes. When :attr:`g` is generated
      from a neighbor sampler, the value should be set to the corresponding
      :attr:`fanout`. This option is used to invoke the MFG-variant of
      cugraph-ops kernel.
  
  Returns
  -------
  torch.Tensor
      Output node features. Shape: :math:`(|V|, D_{out})`.
docstr_tok: ["Forward","computation",".","Parameters","--","--","--","--","--","g",":","DGLGraph","or","SparseGraph","The","graph",".","feat",":","torch.Tensor","or","tuple","Node","features",".","Shape",":",":","math",":","`","(","|V|",",","D_","{","in","}",")","`",".","max_in_degree",":","int","Maximum","in-degree","of","destination","nodes",".","When",":","attr",":","`","g","`","is","generated","from","a","neighbor","sampler",",","the","value","should","be","set","to","the","corresponding",":","attr",":","`","fanout","`",".","This","option","is","used","to","invoke","the","MFG-variant","of","cugraph-ops","kernel",".","Returns","--","--","--","-","torch.Tensor","Output","node","features",".","Shape",":",":","math",":","`","(","|V|",",","D_","{","out","}",")","`","."]
code: def forward(
      self,
      g: Union[SparseGraph, dgl.DGLHeteroGraph],
      feat: Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]],
      max_in_degree: Optional[int] = None,
  ) -> torch.Tensor:
      r"""Forward computation.
  
      Parameters
      ----------
      g : DGLGraph or SparseGraph
          The graph.
      feat : torch.Tensor or tuple
          Node features. Shape: :math:`(|V|, D_{in})`.
      max_in_degree : int
          Maximum in-degree of destination nodes. When :attr:`g` is generated
          from a neighbor sampler, the value should be set to the corresponding
          :attr:`fanout`. This option is used to invoke the MFG-variant of
          cugraph-ops kernel.
  
      Returns
      -------
      torch.Tensor
          Output node features. Shape: :math:`(|V|, D_{out})`.
      """
      feat_bipartite = isinstance(feat, (list, tuple))
      graph_bipartite = feat_bipartite or self.aggregator_type == "pool"
  
      _graph = self.get_cugraph_ops_CSC(
          g, is_bipartite=graph_bipartite, max_in_degree=max_in_degree
      )
  
      if feat_bipartite:
          feat = (self.feat_drop(feat[0]), self.feat_drop(feat[1]))
      else:
          feat = self.feat_drop(feat)
  
      if self.aggregator_type == "pool":
          if feat_bipartite:
              feat = (self.pre_lin(feat[0]).relu(), feat[1])
          else:
              feat = (
                  self.pre_lin(feat).relu(),
                  feat[: g.num_dst_nodes()],
              )
          # force ctx.needs_input_grad=True in cugraph-ops autograd function
          feat[0].requires_grad_()
          feat[1].requires_grad_()
  
      out = ops_torch.operators.agg_concat_n2n(
          feat, _graph, self._aggr
      )[: g.num_dst_nodes()]
  
      if self.aggregator_type == "gcn":
          out = out[:, : self.in_feats_src]
  
      out = self.lin(out)
  
      return out
  
imports: from typing import Optional, Tuple, Union
  from cugraph_dgl.nn.conv.base import BaseConv, SparseGraph
  from cugraph.utilities.utils import import_optional
label_desc: Use image node_id 3 for calling the SAGEConv obj's underlying member method code with example usage: obj.forward(g, feat, max_in_degree) and returns: out