SYMBOL INDEX (276 symbols across 35 files)

FILE: models/dgl/aggregators.py
  function aggregate_mean (line 6) | def aggregate_mean(h):
  function aggregate_max (line 10) | def aggregate_max(h):
  function aggregate_min (line 14) | def aggregate_min(h):
  function aggregate_std (line 18) | def aggregate_std(h):
  function aggregate_var (line 22) | def aggregate_var(h):
  function aggregate_moment (line 29) | def aggregate_moment(h, n=3):
  function aggregate_moment_3 (line 38) | def aggregate_moment_3(h):
  function aggregate_moment_4 (line 42) | def aggregate_moment_4(h):
  function aggregate_moment_5 (line 46) | def aggregate_moment_5(h):
  function aggregate_sum (line 50) | def aggregate_sum(h):

FILE: models/dgl/pna_layer.py
  class PNATower (line 17) | class PNATower(nn.Module):
    method __init__ (line 18) | def __init__(self, in_dim, out_dim, dropout, graph_norm, batch_norm, a...
    method pretrans_edges (line 35) | def pretrans_edges(self, edges):
    method message_func (line 42) | def message_func(self, edges):
    method reduce_func (line 45) | def reduce_func(self, nodes):
    method posttrans_nodes (line 52) | def posttrans_nodes(self, nodes):
    method forward (line 55) | def forward(self, g, h, e, snorm_n):
  class PNALayer (line 79) | class PNALayer(nn.Module):
    method __init__ (line 81) | def __init__(self, in_dim, out_dim, aggregators, scalers, avg_d, dropo...
    method forward (line 130) | def forward(self, g, h, e, snorm_n):
    method __repr__ (line 147) | def __repr__(self):
  class PNASimpleLayer (line 151) | class PNASimpleLayer(nn.Module):
    method __init__ (line 153) | def __init__(self, in_dim, out_dim, aggregators, scalers, avg_d, dropo...
    method reduce_func (line 189) | def reduce_func(self, nodes):
    method forward (line 197) | def forward(self, g, h):
    method __repr__ (line 218) | def __repr__(self):

FILE: models/dgl/scalers.py
  function scale_identity (line 8) | def scale_identity(h, D=None, avg_d=None):
  function scale_amplification (line 12) | def scale_amplification(h, D, avg_d):
  function scale_attenuation (line 17) | def scale_attenuation(h, D, avg_d):

FILE: models/layers.py
  function get_activation (line 8) | def get_activation(activation):
  class Set2Set (line 22) | class Set2Set(torch.nn.Module):
    method __init__ (line 53) | def __init__(self, nin, nhid=None, steps=None, num_layers=1, activatio...
    method forward (line 66) | def forward(self, x):
  class FCLayer (line 101) | class FCLayer(nn.Module):
    method __init__ (line 152) | def __init__(self, in_size, out_size, activation='relu', dropout=0., b...
    method reset_parameters (line 174) | def reset_parameters(self, init_fn=None):
    method forward (line 181) | def forward(self, x):
    method __repr__ (line 194) | def __repr__(self):
  class MLP (line 200) | class MLP(nn.Module):
    method __init__ (line 205) | def __init__(self, in_size, hidden_size, out_size, layers, mid_activat...
    method forward (line 226) | def forward(self, x):
    method __repr__ (line 231) | def __repr__(self):
  class GRU (line 237) | class GRU(nn.Module):
    method __init__ (line 242) | def __init__(self, input_size, hidden_size, device):
    method forward (line 248) | def forward(self, x, y):
  class S2SReadout (line 271) | class S2SReadout(nn.Module):
    method __init__ (line 276) | def __init__(self, in_size, hidden_size, out_size, fc_layers=3, device...
    method forward (line 287) | def forward(self, x):

FILE: models/pytorch/gat/layer.py
  class GATHead (line 6) | class GATHead(nn.Module):
    method __init__ (line 8) | def __init__(self, in_features, out_features, alpha, activation=True, ...
    method reset_parameters (line 20) | def reset_parameters(self):
    method forward (line 24) | def forward(self, input, adj):
    method __repr__ (line 43) | def __repr__(self):
  class GATLayer (line 47) | class GATLayer(nn.Module):
    method __init__ (line 53) | def __init__(self, in_features, out_features, alpha, nheads=1, activat...
    method forward (line 73) | def forward(self, input, adj):
    method __repr__ (line 77) | def __repr__(self):

FILE: models/pytorch/gcn/layer.py
  class GCNLayer (line 7) | class GCNLayer(nn.Module):
    method __init__ (line 13) | def __init__(self, in_features, out_features, bias=True, device='cpu'):
    method reset_parameters (line 31) | def reset_parameters(self):
    method forward (line 37) | def forward(self, X, adj):
    method __repr__ (line 54) | def __repr__(self):

FILE: models/pytorch/gin/layer.py
  class GINLayer (line 6) | class GINLayer(nn.Module):
    method __init__ (line 11) | def __init__(self, in_features, out_features, fc_layers=2, device='cpu'):
    method reset_parameters (line 29) | def reset_parameters(self):
    method forward (line 32) | def forward(self, input, adj):
    method __repr__ (line 42) | def __repr__(self):

FILE: models/pytorch/gnn_framework.py
  class GNN (line 8) | class GNN(nn.Module):
    method __init__ (line 9) | def __init__(self, nfeat, nhid, nodes_out, graph_out, dropout, conv_la...
    method forward (line 86) | def forward(self, x, adj):

FILE: models/pytorch/pna/aggregators.py
  function aggregate_identity (line 10) | def aggregate_identity(X, adj, self_loop=False, device='cpu'):
  function aggregate_mean (line 17) | def aggregate_mean(X, adj, self_loop=False, device='cpu'):
  function aggregate_max (line 30) | def aggregate_max(X, adj, min_value=-math.inf, self_loop=False, device='...
  function aggregate_min (line 42) | def aggregate_min(X, adj, max_value=math.inf, self_loop=False, device='c...
  function aggregate_std (line 54) | def aggregate_std(X, adj, self_loop=False, device='cpu'):
  function aggregate_var (line 61) | def aggregate_var(X, adj, self_loop=False, device='cpu'):
  function aggregate_sum (line 76) | def aggregate_sum(X, adj, self_loop=False, device='cpu'):
  function aggregate_normalised_mean (line 87) | def aggregate_normalised_mean(X, adj, self_loop=False, device='cpu'):
  function aggregate_softmax (line 102) | def aggregate_softmax(X, adj, self_loop=False, device='cpu'):
  function aggregate_softmin (line 117) | def aggregate_softmin(X, adj, self_loop=False, device='cpu'):
  function aggregate_moment (line 122) | def aggregate_moment(X, adj, self_loop=False, device='cpu', n=3):
  function aggregate_moment_3 (line 137) | def aggregate_moment_3(X, adj, self_loop=False, device='cpu'):
  function aggregate_moment_4 (line 141) | def aggregate_moment_4(X, adj, self_loop=False, device='cpu'):
  function aggregate_moment_5 (line 145) | def aggregate_moment_5(X, adj, self_loop=False, device='cpu'):

FILE: models/pytorch/pna/layer.py
  class PNATower (line 9) | class PNATower(nn.Module):
    method __init__ (line 10) | def __init__(self, in_features, out_features, aggregators, scalers, av...
    method forward (line 33) | def forward(self, input, adj):
    method __repr__ (line 51) | def __repr__(self):
  class PNALayer (line 57) | class PNALayer(nn.Module):
    method __init__ (line 63) | def __init__(self, in_features, out_features, aggregators, scalers, av...
    method forward (line 99) | def forward(self, input, adj):
    method __repr__ (line 111) | def __repr__(self):

FILE: models/pytorch/pna/scalers.py
  function scale_identity (line 7) | def scale_identity(X, adj, avg_d=None):
  function scale_amplification (line 11) | def scale_amplification(X, adj, avg_d=None):
  function scale_attenuation (line 19) | def scale_attenuation(X, adj, avg_d=None):
  function scale_linear (line 27) | def scale_linear(X, adj, avg_d=None):
  function scale_inverse_linear (line 34) | def scale_inverse_linear(X, adj, avg_d=None):

FILE: models/pytorch_geometric/aggregators.py
  function aggregate_sum (line 9) | def aggregate_sum(src: Tensor, index: Tensor, dim_size: Optional[int]):
  function aggregate_mean (line 13) | def aggregate_mean(src: Tensor, index: Tensor, dim_size: Optional[int]):
  function aggregate_min (line 17) | def aggregate_min(src: Tensor, index: Tensor, dim_size: Optional[int]):
  function aggregate_max (line 21) | def aggregate_max(src: Tensor, index: Tensor, dim_size: Optional[int]):
  function aggregate_var (line 25) | def aggregate_var(src, index, dim_size):
  function aggregate_std (line 31) | def aggregate_std(src, index, dim_size):

FILE: models/pytorch_geometric/example.py
  class Net (line 27) | class Net(torch.nn.Module):
    method __init__ (line 28) | def __init__(self):
    method forward (line 46) | def forward(self, x, edge_index, edge_attr, batch):
  function train (line 64) | def train(epoch):
  function test (line 81) | def test(loader):

FILE: models/pytorch_geometric/pna.py
  class PNAConv (line 17) | class PNAConv(MessagePassing):
    method __init__ (line 56) | def __init__(self, in_channels: int, out_channels: int,
    method reset_parameters (line 111) | def reset_parameters(self):
    method forward (line 120) | def forward(self, x: Tensor, edge_index: Adj,
    method message (line 137) | def message(self, x_i: Tensor, x_j: Tensor,
    method aggregate (line 152) | def aggregate(self, inputs: Tensor, index: Tensor,
    method __repr__ (line 161) | def __repr__(self):
  class PNAConvSimple (line 167) | class PNAConvSimple(MessagePassing):
    method __init__ (line 198) | def __init__(self, in_channels: int, out_channels: int,
    method reset_parameters (line 230) | def reset_parameters(self):
    method forward (line 233) | def forward(self, x: Tensor, edge_index: Adj, edge_attr: OptTensor = N...
    method message (line 239) | def message(self, x_j: Tensor) -> Tensor:
    method aggregate (line 242) | def aggregate(self, inputs: Tensor, index: Tensor,
    method __repr__ (line 251) | def __repr__(self):

FILE: models/pytorch_geometric/scalers.py
  function scale_identity (line 8) | def scale_identity(src: Tensor, deg: Tensor, avg_deg: Dict[str, float]):
  function scale_amplification (line 12) | def scale_amplification(src: Tensor, deg: Tensor, avg_deg: Dict[str, flo...
  function scale_attenuation (line 16) | def scale_attenuation(src: Tensor, deg: Tensor, avg_deg: Dict[str, float]):
  function scale_linear (line 22) | def scale_linear(src: Tensor, deg: Tensor, avg_deg: Dict[str, float]):
  function scale_inverse_linear (line 26) | def scale_inverse_linear(src: Tensor, deg: Tensor, avg_deg: Dict[str, fl...

FILE: multitask_benchmark/datasets_generation/graph_algorithms.py
  function is_connected (line 7) | def is_connected(A):
  function identity (line 17) | def identity(A, F):
  function first_neighbours (line 26) | def first_neighbours(A):
  function second_neighbours (line 35) | def second_neighbours(A):
  function kth_neighbours (line 47) | def kth_neighbours(A, k):
  function map_reduce_neighbourhood (line 61) | def map_reduce_neighbourhood(A, F, f_reduce, f_map=None, hops=1, conside...
  function max_neighbourhood (line 81) | def max_neighbourhood(A, F):
  function min_neighbourhood (line 90) | def min_neighbourhood(A, F):
  function std_neighbourhood (line 99) | def std_neighbourhood(A, F):
  function mean_neighbourhood (line 108) | def mean_neighbourhood(A, F):
  function local_maxima (line 117) | def local_maxima(A, F):
  function graph_laplacian (line 126) | def graph_laplacian(A):
  function graph_laplacian_features (line 136) | def graph_laplacian_features(A, F):
  function isomorphism (line 145) | def isomorphism(A1, A2, F1=None, F2=None):
  function count_edges (line 189) | def count_edges(A):
  function is_eulerian_cyclable (line 197) | def is_eulerian_cyclable(A):
  function is_eulerian_percorrible (line 205) | def is_eulerian_percorrible(A):
  function map_reduce_graph (line 213) | def map_reduce_graph(A, F, f_reduce):
  function mean_graph (line 222) | def mean_graph(A, F):
  function max_graph (line 231) | def max_graph(A, F):
  function min_graph (line 240) | def min_graph(A, F):
  function std_graph (line 249) | def std_graph(A, F):
  function has_hamiltonian_cycle (line 258) | def has_hamiltonian_cycle(A):
  function all_pairs_shortest_paths (line 290) | def all_pairs_shortest_paths(A, inf_sub=math.inf):
  function diameter (line 314) | def diameter(A):
  function eccentricity (line 325) | def eccentricity(A):
  function sssp_predecessor (line 336) | def sssp_predecessor(A, F):
  function max_eigenvalue (line 361) | def max_eigenvalue(A):
  function max_eigenvalues (line 371) | def max_eigenvalues(A, k):
  function max_absolute_eigenvalues (line 382) | def max_absolute_eigenvalues(A, k):
  function max_absolute_eigenvalues_laplacian (line 391) | def max_absolute_eigenvalues_laplacian(A, n):
  function max_eigenvector (line 401) | def max_eigenvector(A):
  function spectral_radius (line 411) | def spectral_radius(A):
  function page_rank (line 420) | def page_rank(A, F=None, iter=64):
  function tsp_length (line 449) | def tsp_length(A, F=None):
  function get_nodes_labels (line 493) | def get_nodes_labels(A, F):
  function get_graph_labels (line 508) | def get_graph_labels(A, F):

FILE: multitask_benchmark/datasets_generation/graph_generation.py
  class GraphType (line 15) | class GraphType(Enum):
  function erdos_renyi (line 35) | def erdos_renyi(N, degree, seed):
  function barabasi_albert (line 40) | def barabasi_albert(N, degree, seed):
  function grid (line 46) | def grid(N):
  function caveman (line 55) | def caveman(N):
  function tree (line 64) | def tree(N, seed):
  function ladder (line 69) | def ladder(N):
  function line (line 79) | def line(N):
  function star (line 84) | def star(N):
  function caterpillar (line 89) | def caterpillar(N, seed):
  function lobster (line 102) | def lobster(N, seed):
  function randomize (line 119) | def randomize(A):
  function generate_graph (line 149) | def generate_graph(N, type=GraphType.RANDOM, seed=None, degree=None):

FILE: multitask_benchmark/datasets_generation/multitask_dataset.py
  class DatasetMultitask (line 15) | class DatasetMultitask:
    method __init__ (line 17) | def __init__(self, n_graphs, N, seed, graph_type, get_nodes_labels, ge...
    method save_as_pickle (line 83) | def save_as_pickle(self, filename):
  function get_nodes_labels (line 116) | def get_nodes_labels(A, F, initial=None):
  function get_graph_labels (line 124) | def get_graph_labels(A, F):

FILE: multitask_benchmark/util/train.py
  function build_arg_parser (line 21) | def build_arg_parser():
  function execute_train (line 67) | def execute_train(gnn_args, args):

FILE: multitask_benchmark/util/util.py
  function load_dataset (line 8) | def load_dataset(data_path, loss, only_nodes, only_graph, print_baseline...
  function get_loss (line 37) | def get_loss(loss, output, target):
  function total_loss (line 51) | def total_loss(output, target, loss='mse', only_nodes=False, only_graph=...
  function total_loss_multiple_batches (line 69) | def total_loss_multiple_batches(output, target, loss='mse', only_nodes=F...
  function specific_loss (line 78) | def specific_loss(output, target, loss='mse', only_nodes=False, only_gra...
  function specific_loss_multiple_batches (line 96) | def specific_loss_multiple_batches(output, target, loss='mse', only_node...

FILE: realworld_benchmark/data/HIV.py
  class HIVDGL (line 10) | class HIVDGL(torch.utils.data.Dataset):
    method __init__ (line 11) | def __init__(self, data, split):
    method __len__ (line 22) | def __len__(self):
    method __getitem__ (line 26) | def __getitem__(self, idx):
  class HIVDataset (line 42) | class HIVDataset(Dataset):
    method __init__ (line 43) | def __init__(self, name, verbose=True):
    method collate (line 63) | def collate(self, samples):
    method _add_self_loops (line 71) | def _add_self_loops(self):

FILE: realworld_benchmark/data/molecules.py
  class MoleculeDGL (line 14) | class MoleculeDGL(torch.utils.data.Dataset):
    method __init__ (line 15) | def __init__(self, data_dir, split, num_graphs):
    method _prepare (line 45) | def _prepare(self):
    method __len__ (line 69) | def __len__(self):
    method __getitem__ (line 73) | def __getitem__(self, idx):
  class MoleculeDatasetDGL (line 89) | class MoleculeDatasetDGL(torch.utils.data.Dataset):
    method __init__ (line 90) | def __init__(self, name='Zinc'):
  function self_loop (line 105) | def self_loop(g):
  class MoleculeDataset (line 131) | class MoleculeDataset(torch.utils.data.Dataset):
    method __init__ (line 133) | def __init__(self, name):
    method collate (line 153) | def collate(self, samples):
    method _add_self_loops (line 166) | def _add_self_loops(self):

FILE: realworld_benchmark/data/superpixels.py
  function sigma (line 23) | def sigma(dists, kth=8):
  function compute_adjacency_matrix_images (line 37) | def compute_adjacency_matrix_images(coord, feat, use_feat=True, kth=8):
  function compute_edges_list (line 56) | def compute_edges_list(A, kth=8+1):
  class SuperPixDGL (line 78) | class SuperPixDGL(torch.utils.data.Dataset):
    method __init__ (line 79) | def __init__(self,
    method _prepare (line 107) | def _prepare(self):
    method __len__ (line 157) | def __len__(self):
    method __getitem__ (line 161) | def __getitem__(self, idx):
  class DGLFormDataset (line 177) | class DGLFormDataset(torch.utils.data.Dataset):
    method __init__ (line 182) | def __init__(self, *lists):
    method __getitem__ (line 188) | def __getitem__(self, index):
    method __len__ (line 191) | def __len__(self):
  class SuperPixDatasetDGL (line 195) | class SuperPixDatasetDGL(torch.utils.data.Dataset):
    method __init__ (line 196) | def __init__(self, name, num_val=5000):
  function self_loop (line 236) | def self_loop(g):
  class SuperPixDataset (line 263) | class SuperPixDataset(torch.utils.data.Dataset):
    method __init__ (line 265) | def __init__(self, name):
    method collate (line 284) | def collate(self, samples):
    method _add_self_loops (line 300) | def _add_self_loops(self):

FILE: realworld_benchmark/main_HIV.py
  function gpu_setup (line 17) | def gpu_setup(use_gpu, gpu_id):
  function view_model_param (line 30) | def view_model_param(net_params):
  function train_val_pipeline (line 42) | def train_val_pipeline(dataset, params, net_params):
  function main (line 139) | def main():

FILE: realworld_benchmark/main_molecules.py
  class DotDict (line 20) | class DotDict(dict):
    method __init__ (line 21) | def __init__(self, **kwds):
  function gpu_setup (line 38) | def gpu_setup(use_gpu, gpu_id):
  function view_model_param (line 56) | def view_model_param(net_params):
  function train_val_pipeline (line 73) | def train_val_pipeline(dataset, params, net_params, dirs):
  function main (line 196) | def main():

FILE: realworld_benchmark/main_superpixels.py
  class DotDict (line 25) | class DotDict(dict):
    method __init__ (line 26) | def __init__(self, **kwds):
  function gpu_setup (line 44) | def gpu_setup(use_gpu, gpu_id):
  function view_model_param (line 62) | def view_model_param(MODEL_NAME, net_params):
  function train_val_pipeline (line 79) | def train_val_pipeline(MODEL_NAME, dataset, params, net_params, dirs):
  function main (line 210) | def main():

FILE: realworld_benchmark/nets/HIV_graph_classification/pna_net.py
  class PNANet (line 9) | class PNANet(nn.Module):
    method __init__ (line 10) | def __init__(self, net_params):
    method forward (line 42) | def forward(self, g, h):
    method loss (line 62) | def loss(self, scores, labels):

FILE: realworld_benchmark/nets/gru.py
  class GRU (line 5) | class GRU(nn.Module):
    method __init__ (line 10) | def __init__(self, input_size, hidden_size, device):
    method forward (line 16) | def forward(self, x, y):

FILE: realworld_benchmark/nets/mlp_readout_layer.py
  class MLPReadout (line 14) | class MLPReadout(nn.Module):
    method __init__ (line 16) | def __init__(self, input_dim, output_dim, L=2):  # L=nb_hidden_layers
    method forward (line 23) | def forward(self, x):

FILE: realworld_benchmark/nets/molecules_graph_regression/pna_net.py
  class PNANet (line 16) | class PNANet(nn.Module):
    method __init__ (line 17) | def __init__(self, net_params):
    method forward (line 69) | def forward(self, g, h, e, snorm_n, snorm_e):
    method loss (line 94) | def loss(self, scores, targets):

FILE: realworld_benchmark/nets/superpixels_graph_classification/pna_net.py
  class PNANet (line 17) | class PNANet(nn.Module):
    method __init__ (line 18) | def __init__(self, net_params):
    method forward (line 70) | def forward(self, g, h, e, snorm_n, snorm_e):
    method loss (line 94) | def loss(self, pred, label):

FILE: realworld_benchmark/train/metrics.py
  function MAE (line 14) | def MAE(scores, targets):
  function accuracy_TU (line 19) | def accuracy_TU(scores, targets):
  function accuracy_MNIST_CIFAR (line 25) | def accuracy_MNIST_CIFAR(scores, targets):
  function accuracy_CITATION_GRAPH (line 30) | def accuracy_CITATION_GRAPH(scores, targets):
  function accuracy_SBM (line 37) | def accuracy_SBM(scores, targets):
  function binary_f1_score (line 57) | def binary_f1_score(scores, targets):
  function accuracy_VOC (line 67) | def accuracy_VOC(scores, targets):

FILE: realworld_benchmark/train/train_HIV_graph_classification.py
  function train_epoch_sparse (line 4) | def train_epoch_sparse(model, optimizer, device, data_loader, epoch):
  function evaluate_network_sparse (line 29) | def evaluate_network_sparse(model, device, data_loader, epoch):

FILE: realworld_benchmark/train/train_molecules_graph_regression.py
  function train_epoch (line 15) | def train_epoch(model, optimizer, device, data_loader, epoch):
  function evaluate_network (line 41) | def evaluate_network(model, device, data_loader, epoch):

FILE: realworld_benchmark/train/train_superpixels_graph_classification.py
  function train_epoch (line 15) | def train_epoch(model, optimizer, device, data_loader, epoch):
  function evaluate_network (line 41) | def evaluate_network(model, device, data_loader, epoch):