fix

Author: EdisonLeeeee

graphgallery/data/_util.py

@@ -1,3 +1,6 @@
+"""
+Unused
+"""
 import functools
 import operator
 import sys
@@ -116,7 +119,7 @@ def _aligned_zeros(shape, dtype=float, order="C", align=None):
         offset = align - offset
     # Note: slices producing 0-size arrays do not necessarily change
     # data pointer --- so we use and allocate size+1
-    buf = buf[offset:offset+size+1][:-1]
+    buf = buf[offset:offset + size + 1][:-1]
     data = np.ndarray(shape, dtype, buf, order=order)
     data.fill(0)
     return data

graphgallery/data/utils.py

@@ -1,4 +1,6 @@
 """ Utility functions for sparse matrix module
+
+Unused
 """
 
 import sys
@@ -296,13 +298,15 @@ def check_shape(args, current_shape=None):
                                  .format(current_size, new_shape))
         elif len(negative_indexes) == 1:
             skip = negative_indexes[0]
-            specified = prod(new_shape[0:skip] + new_shape[skip+1:])
+            specified = prod(new_shape[0:skip] + new_shape[skip + 1:])
             unspecified, remainder = divmod(current_size, specified)
             if remainder != 0:
-                err_shape = tuple('newshape' if x < 0 else x for x in new_shape)
+                err_shape = tuple('newshape' if x <
+                                  0 else x for x in new_shape)
                 raise ValueError('cannot reshape array of size {} into shape {}'
                                  ''.format(current_size, err_shape))
-            new_shape = new_shape[0:skip] + (unspecified,) + new_shape[skip+1:]
+            new_shape = new_shape[0:skip] + \
+                (unspecified,) + new_shape[skip + 1:]
         else:
             raise ValueError('can only specify one unknown dimension')
 

graphgallery/nn/__init__.py

@@ -1,3 +1,4 @@
 from graphgallery.nn.layers import *
 from graphgallery.nn.models import *
-from graphgallery.nn.functions import *
+from graphgallery.nn.functions import *
+from graphgallery.nn.init import *

graphgallery/nn/layers/__init__.py

@@ -23,4 +23,3 @@
 
 else:
     from graphgallery.nn.layers.torch_layers.gcn import GraphConvolution
-

graphgallery/nn/layers/tf_layers/misc.py

@@ -111,17 +111,19 @@ def get_config(self):
 
 
 class Laplacian(Layer):
-    def __init__(self, rate=-0.5, selfloop=1.0, *args, **kwargs):
+    def __init__(self, rate=-0.5, fill_weight=1.0, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if not rate:
             raise ValueError(
                 f"`rate` must be an integer scalr larger than zero, but got {rate}.")
         self.rate = rate
-        self.selfloop = selfloop
+        self.fill_weight = fill_weight
         self.trainable = False
 
     def call(self, adj):
-        adj = adj + self.selfloop * tf.eye(tf.shape(adj)[0], dtype=adj.dtype)
+        if self.fill_weight:
+            adj = adj + self.fill_weight * \
+                tf.eye(tf.shape(adj)[0], dtype=adj.dtype)
         d = tf.reduce_sum(adj, axis=1)
         d_power = tf.pow(d, self.rate)
         d_power_mat = tf.linalg.diag(d_power)

graphgallery/nn/layers/tf_layers/normalize.py

@@ -22,7 +22,7 @@ def call(self, inputs, improved=False):
             edge_weight = tf.ones([edge_index.shape[0]], dtype=floatx())
 
         fill_weight = 2.0 if improved else 1.0
-        edge_index, edge_weight = self.add_selfloop_edge(
+        edge_index, edge_weight = self.add_selfloops_edge(
             edge_index, n_nodes, edge_weight=edge_weight, fill_weight=fill_weight)
 
         row = tf.gather(edge_index, 0, axis=1)
@@ -41,7 +41,7 @@ def call(self, inputs, improved=False):
         return edge_index, noremd_edge_weight
 
     @staticmethod
-    def add_selfloop_edge(edge_index, n_nodes, edge_weight=None, fill_weight=1.0):
+    def add_selfloops_edge(edge_index, n_nodes, edge_weight=None, fill_weight=1.0):
         diagnal_edge_index = tf.reshape(
             tf.repeat(tf.range(n_nodes, dtype=intx()), 2), [n_nodes, 2])
 

graphgallery/nn/layers/torch_layers/gcn.py

@@ -1,77 +1,40 @@
-import numpy as np
 import torch
+import math
+import numpy as np
 from torch.nn.parameter import Parameter
 from torch.nn import Module
+from graphgallery.nn.init import kaiming_uniform, zeros
 
+# TODO: change dtypes of trainable weights based on `floax`
 class GraphConvolution(Module):
-    def __init__(self, input_channels, output_channels, use_bias=False):
+    def __init__(self, in_channels, out_channels, use_bias=False):
         super().__init__()
-        self.input_channels = input_channels
-        self.output_channels = output_channels
-        self.kernel = Parameter(torch.FloatTensor(input_channels, output_channels))
-        
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel = Parameter(torch.Tensor(in_channels, out_channels))
+
         if use_bias:
-            self.bias = Parameter(torch.FloatTensor(output_channels))
+            self.bias = Parameter(torch.Tensor(out_channels))
         else:
             self.register_parameter('bias', None)
-            
+
         self.reset_parameters()
 
     def reset_parameters(self):
-        stdv = 1. / np.sqrt(self.kernel.size(1))
-        self.kernel.data.uniform_(-stdv, stdv)
-        if self.bias is not None:
-            self.bias.data.uniform_(-stdv, stdv)
+        kaiming_uniform(self.kernel, a=math.sqrt(5))
+        zeros(self.bias)
 
     def forward(self, inputs):
         x, adj = inputs
         h = torch.spmm(x, self.kernel)
         output = torch.spmm(adj, h)
-        
+
         if self.bias is not None:
             return output + self.bias
         else:
             return output
 
     def __repr__(self):
         return self.__class__.__name__ + ' (' \
-               + str(self.input_channels) + ' -> ' \
-               + str(self.output_channels) + ')'
-    
-    
-class ListModule(Module):
-    """
-    Abstract list layer class.
-    """
-    def __init__(self, *args):
-        """
-        Module initializing.
-        """
-        super().__init__()
-        idx = 0
-        for module in args:
-            self.add_module(str(idx), module)
-            idx += 1
-
-    def __getitem__(self, idx):
-        """
-        Getting the indexed layer.
-        """
-        if idx < 0 or idx >= len(self._modules):
-            raise IndexError('index {} is out of range'.format(idx))
-        it = iter(self._modules.values())
-        for i in range(idx):
-            next(it)
-        return next(it)
-
-    def __iter__(self):
-        """
-        Iterating on the layers.
-        """
-        return iter(self._modules.values())
-
-    def __len__(self):
-        """
-        Number of layers.
-        """
-        return len(self._modules)    
+            + str(self.in_channels) + ' -> ' \
+            + str(self.out_channels) + ')'

graphgallery/nn/layers/torch_layers/inits.py

@@ -85,6 +85,7 @@ def process_step(self):
             self.feature_inputs, self.structure_inputs = T.astensors(
                 attr_matrix, (edge_index, edge_weight))
 
+    # use decorator to make sure all list arguments have the same length
     @EqualVarLength()
     def build(self, hiddens=[16], activations=['relu'], dropouts=[0.5],
               l2_norms=[5e-4], lr=0.01, use_bias=False):