class_docstr: Dataset Class for `How Powerful Are Graph Neural Networks? <https://arxiv.org/abs/1810.00826>`_.
  
  This is adapted from `<https://github.com/weihua916/powerful-gnns/blob/master/dataset.zip>`_.
  
  The class provides an interface for nine datasets used in the paper along with the paper-specific
  settings. The datasets are ``'MUTAG'``, ``'COLLAB'``, ``'IMDBBINARY'``, ``'IMDBMULTI'``,
  ``'NCI1'``, ``'PROTEINS'``, ``'PTC'``, ``'REDDITBINARY'``, ``'REDDITMULTI5K'``.
  
  If ``degree_as_nlabel`` is set to ``False``, then ``ndata['label']`` stores the provided node label,
  otherwise ``ndata['label']`` stores the node in-degrees.
  
  For graphs that have node attributes, ``ndata['attr']`` stores the node attributes.
  For graphs that have no attribute, ``ndata['attr']`` stores the corresponding one-hot encoding
  of ``ndata['label']``.
  
  Parameters
  ---------
  name: str
      dataset name, one of
      (``'MUTAG'``, ``'COLLAB'``,         ``'IMDBBINARY'``, ``'IMDBMULTI'``,         ``'NCI1'``, ``'PROTEINS'``, ``'PTC'``,         ``'REDDITBINARY'``, ``'REDDITMULTI5K'``)
  self_loop: bool
      add self to self edge if true
  degree_as_nlabel: bool
      take node degree as label and feature if true
  transform: callable, optional
      A transform that takes in a :class:`~dgl.DGLGraph` object and returns
      a transformed version. The :class:`~dgl.DGLGraph` object will be
      transformed before every access.
  
  Attributes
  ----------
  num_classes : int
      Number of classes for multiclass classification
  
  Examples
  --------
  >>> data = GINDataset(name='MUTAG', self_loop=False)
  
  The dataset instance is an iterable
  
  >>> len(data)
  188
  >>> g, label = data[128]
  >>> g
  Graph(num_nodes=13, num_edges=26,
        ndata_schemes={'label': Scheme(shape=(), dtype=torch.int64), 'attr': Scheme(shape=(7,), dtype=torch.float32)}
        edata_schemes={})
  >>> label
  tensor(1)
  
  Batch the graphs and labels for mini-batch training
  
  >>> graphs, labels = zip(*[data[i] for i in range(16)])
  >>> batched_graphs = dgl.batch(graphs)
  >>> batched_labels = torch.tensor(labels)
  >>> batched_graphs
  Graph(num_nodes=330, num_edges=748,
        ndata_schemes={'label': Scheme(shape=(), dtype=torch.int64), 'attr': Scheme(shape=(7,), dtype=torch.float32)}
        edata_schemes={})
class_docstr_tok: ["Dataset","Class","for","`","How","Powerful","Are","Graph","Neural","Networks","?","<","https",":","\/\/arxiv.org\/abs\/1810.00826",">","`","_",".","This","is","adapted","from","`","<","https",":","\/\/github.com\/weihua916\/powerful-gnns\/blob\/master\/dataset.zip",">","`","_",".","The","class","provides","an","interface","for","nine","datasets","used","in","the","paper","along","with","the","paper-specific","settings",".","The","datasets","are","``","'MUTAG","'","``",",","``","'COLLAB","'","``",",","``","'IMDBBINARY","'","``",",","``","'IMDBMULTI","'","``",",","``","'NCI1","'","``",",","``","'PROTEINS","'","``",",","``","'PTC","'","``",",","``","'REDDITBINARY","'","``",",","``","'REDDITMULTI5K","'","``",".","If","``","degree_as_nlabel","``","is","set","to","``","False","``",",","then","``","ndata","[","'label","'","]","``","stores","the","provided","node","label",",","otherwise","``","ndata","[","'label","'","]","``","stores","the","node","in-degrees",".","For","graphs","that","have","node","attributes",",","``","ndata","[","'attr","'","]","``","stores","the","node","attributes",".","For","graphs","that","have","no","attribute",",","``","ndata","[","'attr","'","]","``","stores","the","corresponding","one-hot","encoding","of","``","ndata","[","'label","'","]","``",".","Parameters","--","--","--","--","-","name",":","str","dataset","name",",","one","of","(","``","'MUTAG","'","``",",","``","'COLLAB","'","``",",","``","'IMDBBINARY","'","``",",","``","'IMDBMULTI","'","``",",","``","'NCI1","'","``",",","``","'PROTEINS","'","``",",","``","'PTC","'","``",",","``","'REDDITBINARY","'","``",",","``","'REDDITMULTI5K","'","``",")","self_loop",":","bool","add","self","to","self","edge","if","true","degree_as_nlabel",":","bool","take","node","degree","as","label","and","feature","if","true","transform",":","callable",",","optional","A","transform","that","takes","in","a",":","class",":","`","~dgl.DGLGraph","`","object","and","returns","a","transformed","version",".","The",":","class",":","`","~dgl.DGLGraph","`","object","will","be","transformed","before","every","access",".","Attributes","--","--","--","--","--","num_classes",":","int","Number","of","classes","for","multiclass","classification","Examples","--","--","--","--",">",">",">","data","=","GINDataset","(","name='MUTAG","'",",","self_loop=False",")","The","dataset","instance","is","an","iterable",">",">",">","len","(","data",")","188",">",">",">","g",",","label","=","data","[","128","]",">",">",">","g","Graph","(","num_nodes=13",",","num_edges=26",",","ndata_schemes=","{","'label","'",":","Scheme","(","shape=","(",")",",","dtype=torch.int64",")",",","'attr","'",":","Scheme","(","shape=","(","7",",",")",",","dtype=torch.float32",")","}","edata_schemes=","{","}",")",">",">",">","label","tensor","(","1",")","Batch","the","graphs","and","labels","for","mini-batch","training",">",">",">","graphs",",","labels","=","zip","(","*","[","data","[","i","]","for","i","in","range","(","16",")","]",")",">",">",">","batched_graphs","=","dgl.batch","(","graphs",")",">",">",">","batched_labels","=","torch.tensor","(","labels",")",">",">",">","batched_graphs","Graph","(","num_nodes=330",",","num_edges=748",",","ndata_schemes=","{","'label","'",":","Scheme","(","shape=","(",")",",","dtype=torch.int64",")",",","'attr","'",":","Scheme","(","shape=","(","7",",",")",",","dtype=torch.float32",")","}","edata_schemes=","{","}",")"]
docstr: Loads input dataset from dataset/NAME/NAME.txt file
docstr_tok: ["Loads","input","dataset","from","dataset\/NAME\/NAME.txt","file"]
code: def process(self):
      """Loads input dataset from dataset/NAME/NAME.txt file"""
      if self.verbose:
          print("loading data...")
      self.file = self._file_path()
      with open(self.file, "r") as f:
          # line_1 == N, total number of graphs
          self.N = int(f.readline().strip())
  
          for i in range(self.N):
              if (i + 1) % 10 == 0 and self.verbose is True:
                  print("processing graph {}...".format(i + 1))
  
              grow = f.readline().strip().split()
              # line_2 == [n_nodes, l] is equal to
              # [node number of a graph, class label of a graph]
              n_nodes, glabel = [int(w) for w in grow]
  
              # relabel graphs
              if glabel not in self.glabel_dict:
                  mapped = len(self.glabel_dict)
                  self.glabel_dict[glabel] = mapped
  
              self.labels.append(self.glabel_dict[glabel])
  
              g = dgl_graph(([], []))
              g.add_nodes(n_nodes)
  
              nlabels = []  # node labels
              nattrs = []  # node attributes if it has
              m_edges = 0
  
              for j in range(n_nodes):
                  nrow = f.readline().strip().split()
  
                  # handle edges and attributes(if has)
                  tmp = int(nrow[1]) + 2  # tmp == 2 + #edges
                  if tmp == len(nrow):
                      # no node attributes
                      nrow = [int(w) for w in nrow]
                  elif tmp > len(nrow):
                      nrow = [int(w) for w in nrow[:tmp]]
                      nattr = [float(w) for w in nrow[tmp:]]
                      nattrs.append(nattr)
                  else:
                      raise Exception("edge number is incorrect!")
  
                  # relabel nodes if it has labels
                  # if it doesn't have node labels, then every nrow[0]==0
                  if not nrow[0] in self.nlabel_dict:
                      mapped = len(self.nlabel_dict)
                      self.nlabel_dict[nrow[0]] = mapped
  
                  nlabels.append(self.nlabel_dict[nrow[0]])
  
                  m_edges += nrow[1]
                  g.add_edges(j, nrow[2:])
  
                  # add self loop
                  if self.self_loop:
                      m_edges += 1
                      g.add_edges(j, j)
  
                  if (j + 1) % 10 == 0 and self.verbose is True:
                      print(
                          "processing node {} of graph {}...".format(
                              j + 1, i + 1
                          )
                      )
                      print("this node has {} edgs.".format(nrow[1]))
  
              if nattrs != []:
                  nattrs = np.stack(nattrs)
                  g.ndata["attr"] = F.tensor(nattrs, F.float32)
                  self.nattrs_flag = True
  
              g.ndata["label"] = F.tensor(nlabels)
              if len(self.nlabel_dict) > 1:
                  self.nlabels_flag = True
  
              assert g.num_nodes() == n_nodes
  
              # update statistics of graphs
              self.n += n_nodes
              self.m += m_edges
  
              self.graphs.append(g)
  
      self.labels = F.tensor(self.labels)
      # if no attr
      if not self.nattrs_flag:
          if self.verbose:
              print("there are no node features in this dataset!")
          # generate node attr by node degree
          if self.degree_as_nlabel:
              if self.verbose:
                  print("generate node features by node degree...")
              for g in self.graphs:
                  # actually this label shouldn't be updated
                  # in case users want to keep it
                  # but usually no features means no labels, fine.
                  g.ndata["label"] = g.in_degrees()
                  # extracting unique node labels
  
          # in case the labels/degrees are not continuous number
          nlabel_set = set([])
          for g in self.graphs:
              nlabel_set = nlabel_set.union(
                  set([F.as_scalar(nl) for nl in g.ndata["label"]])
              )
          nlabel_set = list(nlabel_set)
          is_label_valid = all(
              [label in self.nlabel_dict for label in nlabel_set]
          )
          if (
              is_label_valid
              and len(nlabel_set) == np.max(nlabel_set) + 1
              and np.min(nlabel_set) == 0
          ):
              # Note this is different from the author's implementation. In weihua916's implementation,
              # the labels are relabeled anyway. But here we didn't relabel it if the labels are contiguous
              # to make it consistent with the original dataset
              label2idx = self.nlabel_dict
          else:
              label2idx = {
                  nlabel_set[i]: i for i in range(len(nlabel_set))
              }
          # generate node attr by node label
          for g in self.graphs:
              attr = np.zeros((g.num_nodes(), len(label2idx)))
              attr[
                  range(g.num_nodes()),
                  [
                      label2idx[nl]
                      for nl in F.asnumpy(g.ndata["label"]).tolist()
                  ],
              ] = 1
              g.ndata["attr"] = F.tensor(attr, F.float32)
  
      # after load, get the #classes and #dim
      self.gclasses = len(self.glabel_dict)
      self.nclasses = len(self.nlabel_dict)
      self.eclasses = len(self.elabel_dict)
      self.dim_nfeats = len(self.graphs[0].ndata["attr"][0])
  
      if self.verbose:
          print("Done.")
          print(
              """
                  -------- Data Statistics --------'
                  #Graphs: %d
                  #Graph Classes: %d
                  #Nodes: %d
                  #Node Classes: %d
                  #Node Features Dim: %d
                  #Edges: %d
                  #Edge Classes: %d
                  Avg. of #Nodes: %.2f
                  Avg. of #Edges: %.2f
                  Graph Relabeled: %s
                  Node Relabeled: %s
                  Degree Relabeled(If degree_as_nlabel=True): %s \n """
              % (
                  self.N,
                  self.gclasses,
                  self.n,
                  self.nclasses,
                  self.dim_nfeats,
                  self.m,
                  self.eclasses,
                  self.n / self.N,
                  self.m / self.N,
                  self.glabel_dict,
                  self.nlabel_dict,
                  self.ndegree_dict,
              )
          )
  
imports: import os
  import numpy
  from ..None import backend
  from ..convert import graph
  from ..utils import retry_method_with_fix
  from .dgl_dataset import DGLBuiltinDataset
  from .utils import download, extract_archive, load_graphs, load_info, loadtxt, save_graphs, save_info
label_desc: Use image node_id 7 for calling the GINDataset obj's underlying member method code with example usage: obj.process() without return types