GraphSAGE 代碼解析(二) - layers.py

原創文章～轉載請注明出處哦。其他部分內容參見以下鏈接～

GraphSAGE 代碼解析(一) - unsupervised_train.py

GraphSAGE 代碼解析(三) - aggregators.py

GraphSAGE 代碼解析(四) - models.py

 

 1 # global unique layer ID dictionary for layer name assignment
 2 _LAYER_UIDS = {}
 3 
 4 def get_layer_uid(layer_name=''):
 5     """Helper function, assigns unique layer IDs."""
 6     if layer_name not in _LAYER_UIDS:
 7         _LAYER_UIDS[layer_name] = 1
 8         return 1
 9     else:
10         _LAYER_UIDS[layer_name] += 1
11         return _LAYER_UIDS[layer_name]

 

 

這里_LAYER_UIDS = {} 是記錄layer及其出現次數的字典。

在 get_layer_uid()函數中，若layer_name從未出現過，如今出現了，則將_LAYER_UIDS[layer_name]設為1；否則累加。

作用： 在class Layer中，當未賦variable scope的name時，通過實例化Layer的次數來標定不同的layer_id.

例子：簡化一下class Layer可以看出：

class Layer():
    def __init__(self):
        layer = self.__class__.__name__
        name = layer + '_' + str(get_layer_uid(layer))
        print(name) 

layer1 = Layer()
layer2 = Layer()

# Output:
# Layer_1
# Layer_2

 2. class Layer

class Layer主要定義基本的層的API。

class Layer(object):
    """Base layer class. Defines basic API for all layer objects.
    Implementation inspired by keras (http://keras.io).
    # Properties
        name: String, defines the variable scope of the layer.
        logging: Boolean, switches Tensorflow histogram logging on/off

    # Methods
        _call(inputs): Defines computation graph of layer
            (i.e. takes input, returns output)
        __call__(inputs): Wrapper for _call()
        _log_vars(): Log all variables
    """

    def __init__(self, **kwargs):
        allowed_kwargs = {'name', 'logging', 'model_size'}
        for kwarg in kwargs.keys():
            assert kwarg in allowed_kwargs, 'Invalid keyword argument: ' + kwarg
        name = kwargs.get('name')
        if not name:
            layer = self.__class__.__name__.lower() # "layer"
            name = layer + '_' + str(get_layer_uid(layer))
        self.name = name
        self.vars = {}
        logging = kwargs.get('logging', False)
        self.logging = logging
        self.sparse_inputs = False

    def _call(self, inputs):
        return inputs

    def __call__(self, inputs):
        with tf.name_scope(self.name):
            if self.logging and not self.sparse_inputs:
                tf.summary.histogram(self.name + '/inputs', inputs)
            outputs = self._call(inputs)
            if self.logging:
                tf.summary.histogram(self.name + '/outputs', outputs)
            return outputs

    def _log_vars(self):
        for var in self.vars:
            tf.summary.histogram(self.name + '/vars/' + var, self.vars[var])

方法：

__init__(): 獲取傳入的name, logging, model_size參數。初始化實例變量name, vars{}, logging, sparse_inputs

_call(inputs): 定義層的計算圖：獲取input, 返回output.

__call__(inputs): 相當於_call()的裝飾器，在實現列_call()基本功能后，豐富了其功能，這里主要通過tf.summary.histogram() 可以查看inputs與outputs分布情況的直方圖。

_log_vars(): 記錄所有變量。實現時主要將vars中的各個變量以直方圖形式顯示。

3. class Dense

Dense layer主要用於實現全連接層的基本功能。即為了最終得到 Relu(Wx + b)。

__init__(): 用於獲取初始化成員變量。其中num_features_nonzero和featureless的作用目前還不清楚。

_call(): 用於實現並且返回Relu(Wx + b)

class Dense(Layer):
    """Dense layer."""

    def __init__(self, input_dim, output_dim, dropout=0.,
                 act=tf.nn.relu, placeholders=None, bias=True, featureless=False,
                 sparse_inputs=False, **kwargs):
        super(Dense, self).__init__(**kwargs)

        self.dropout = dropout

        self.act = act
        self.featureless = featureless
        self.bias = bias
        self.input_dim = input_dim
        self.output_dim = output_dim

        # helper variable for sparse dropout
        self.sparse_inputs = sparse_inputs
        if sparse_inputs:
            self.num_features_nonzero = placeholders['num_features_nonzero']

        with tf.variable_scope(self.name + '_vars'):
            self.vars['weights'] = tf.get_variable('weights', shape=(input_dim, output_dim),
        dtype=tf.float32, initializer=tf.contrib.layers.xavier_initializer(),                                             
        regularizer=tf.contrib.layers.l2_regularizer(FLAGS.weight_decay))
            if self.bias:
                self.vars['bias'] = zeros([output_dim], name='bias')

        if self.logging:
            self._log_vars()

    def _call(self, inputs):
        x = inputs
        x = tf.nn.dropout(x, 1 - self.dropout)

        # transform
        output = tf.matmul(x, self.vars['weights'])

        # bias
        if self.bias:
            output += self.vars['bias']

        return self.act(output)