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>)
code: def __init__(
      self,
      in_feats: Union[int, Tuple[int, int]],
      out_feats: int,
      aggregator_type: str = "mean",
      feat_drop: float = 0.0,
      bias: bool = True,
  ):
      super().__init__()
  
      if aggregator_type not in self.valid_aggr_types:
          raise ValueError(
              f"Invalid aggregator_type. Must be one of {self.valid_aggr_types}. "
              f"But got '{aggregator_type}' instead."
          )
  
      self.aggregator_type = aggregator_type
      self._aggr = aggregator_type
      self.in_feats = in_feats
      self.out_feats = out_feats
      self.in_feats_src, self.in_feats_dst = dgl.utils.expand_as_pair(
          in_feats
      )
      self.feat_drop = nn.Dropout(feat_drop)
  
      if self.aggregator_type == "gcn":
          self._aggr = "mean"
          self.lin = nn.Linear(self.in_feats_src, out_feats, bias=bias)
      else:
          self.lin = nn.Linear(
              self.in_feats_src + self.in_feats_dst,
              out_feats,
              bias=bias,
          )
  
      if self.aggregator_type == "pool":
          self._aggr = "max"
          self.pre_lin = nn.Linear(self.in_feats_src, self.in_feats_src)
      else:
          self.register_parameter("pre_lin", None)
  
      self.reset_parameters()
  
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 1 to create a new SAGEConv object from inherited base classes: BaseConv with example: obj = SAGEConv(in_feats, out_feats, aggregator_type, feat_drop, bias)