class_docstr: Differentiable function that performs a graph convolution 
  given adjacency matrix G and feature matrix X
class_docstr_tok: ["Differentiable","function","that","performs","a","graph","convolution","given","adjacency","matrix","G","and","feature","matrix","X"]
docstr: Defines the operations available in this module.
  
  n_conv_layers: int, number of graph convolution layers 
  max_n_atoms: int, N, n_rows (n_cols) of adjacency matrix 
  n_atom_types: int, number of features describing each atom in 
      input 
  conv_layer_dims: list of ints, output n_features for each 
      graph conv layer 
  n_fc_layers: int, number of fully connected layers
  fc_layer_dims: list of ints, output n_features for each 
      fully connected layer 
  dropout: float, probability of zeroing out a given output neuron 
  return_sigmoid: boolean, determines if forward pass 
      returns sigmoid activation on the final layer
docstr_tok: ["Defines","the","operations","available","in","this","module",".","n_conv_layers",":","int",",","number","of","graph","convolution","layers","max_n_atoms",":","int",",","N",",","n_rows","(","n_cols",")","of","adjacency","matrix","n_atom_types",":","int",",","number","of","features","describing","each","atom","in","input","conv_layer_dims",":","list","of","ints",",","output","n_features","for","each","graph","conv","layer","n_fc_layers",":","int",",","number","of","fully","connected","layers","fc_layer_dims",":","list","of","ints",",","output","n_features","for","each","fully","connected","layer","dropout",":","float",",","probability","of","zeroing","out","a","given","output","neuron","return_sigmoid",":","boolean",",","determines","if","forward","pass","returns","sigmoid","activation","on","the","final","layer"]
code: def __init__(
      self,
      n_conv_layers=1,
      max_n_atoms=200,
      n_atom_types=75,
      conv_layer_dims=[64, 128, 256],
      n_fc_layers=2,
      fc_layer_dims=[64, 10],
      dropout=0.0,
      return_sigmoid=True,
  ):
      """
      Defines the operations available in this module.
  
      n_conv_layers: int, number of graph convolution layers
      max_n_atoms: int, N, n_rows (n_cols) of adjacency matrix
      n_atom_types: int, number of features describing each atom in
          input
      conv_layer_dims: list of ints, output n_features for each
          graph conv layer
      n_fc_layers: int, number of fully connected layers
      fc_layer_dims: list of ints, output n_features for each
          fully connected layer
      dropout: float, probability of zeroing out a given output neuron
      return_sigmoid: boolean, determines if forward pass
          returns sigmoid activation on the final layer
      """
  
      super(GraphConvolution, self).__init__()
  
      self.n_conv_layers = n_conv_layers
      self.max_n_atoms = max_n_atoms
      self.n_atom_types = n_atom_types
      self.fc_layer_dims = fc_layer_dims
      self.n_fc_layers = n_fc_layers
      self.return_sigmoid = return_sigmoid
  
      self.conv_layer_dims = [n_atom_types] + conv_layer_dims
      self.dropout = dropout
  
      self.conv_ops = nn.ModuleList()
      for layer_idx in range(self.n_conv_layers):
          p_in = self.conv_layer_dims[layer_idx]
          p_out = self.conv_layer_dims[layer_idx + 1]
          op = nn.Sequential(
              nn.Linear(p_in, p_out),
              nn.Dropout(p=self.dropout),
              nn.ReLU(inplace=True),
              nn.BatchNorm1d(p_out),
          )
          self.conv_ops.append(op)
  
      self.fc_ops = nn.ModuleList()
  
      self.fc_layer_dims = [
          self.conv_layer_dims[self.n_conv_layers]
      ] + self.fc_layer_dims
  
      for layer_idx in range(self.n_fc_layers):
          p_in = self.fc_layer_dims[layer_idx]
          p_out = self.fc_layer_dims[layer_idx + 1]
          op = nn.Sequential(
              nn.Linear(p_in, p_out),
              nn.Dropout(p=self.dropout),
              nn.ReLU(inplace=True),
              nn.BatchNorm1d(p_out),
          )
          self.fc_ops.append(op)
  
      for m in self.modules():
          if isinstance(m, nn.Conv3d):
              n = (
                  m.kernel_size[0]
                  * m.kernel_size[1]
                  * m.kernel_size[2]
                  * m.out_channels
              )
              m.weight.data.normal_(0, np.sqrt(2.0 / n))
          elif m.__class__.__name__.find("BatchNorm") != -1:
              m.weight.data.fill_(1)
              m.bias.data.zero_()
          elif isinstance(m, nn.Linear):
              m.weight.data.normal_(0.0, 0.02)
  
imports: import torch.nn
  import torch.nn.parallel
  import torch.backends.cudnn
  from torch.autograd import Variable
  import torch.optim
  import random
  import numpy
  from sklearn.metrics import roc_auc_score
label_desc: Use image node_id 1 to create a new GraphConvolution object from inherited base classes: nn with example: obj = GraphConvolution(n_conv_layers, max_n_atoms, n_atom_types, conv_layer_dims, n_fc_layers, fc_layer_dims, dropout, return_sigmoid)