NodeLayer Class Reference

Inheritance diagram for NodeLayer:

Collaboration diagram for NodeLayer:

Public Member Functions
def	__init__ (self, nfeat_in_dim, efeat_in_dim, gfeat_in_dim, nfeat_hid_dim, nfeat_out_dim, num_hid_layers, dropout, normalize=True)
def	forward (self, x, edge_index, edge_attr, u, batch)

Public Attributes
	nonlin_function
	Non-linear activation.
	num_hid_layers
	Number of hidden layers.
	dropout_prob
	Dropout probability.
	normalize
	Normalize.
	lin_in
	Input linear layer.
	lins_hid
	Intermediate linear layers.
	lin_out
	Output linear layer.
	norm
	Batch normalization.

Detailed Description

Updates node features in MetaLayer:

.. math::
    v_{i}^{'} = \\phi^{v}(v_{i}, \\rho^{e \\to v}(v_{i}), u)

with

.. math::
    \\rho^{e \\to v}(v_{i}) = \\frac{\\sum_{j=1,\\ j \\neq i}^{N} (e_{ji} + e _{ij})}{2 \\cdot (N-1)},

where :math:`\\phi^{v}` is a neural network of the form

.. figure:: figs/MLP_structure.png
    :width: 42em
    :align: center

Args:
    nfeat_in_dim (int): Node features input dimension (number of node features in input).
    efeat_in_dim (int): Edge features input dimension (number of edge features in input).
    gfeat_in_dim (int): Gloabl features input dimension (number of global features in input).
    nfeat_hid_dim (int): Node features dimension in hidden layers.
    nfeat_out_dim (int): Node features output dimension.
    num_hid_layers (int): Number of hidden layers.
    dropout (float): Dropout rate :math:`r \\in [0,1]`.
    normalize (str): Type of normalization (batch/layer).

:return: Updated node features tensor.
:rtype: `Tensor <https://pytorch.org/docs/stable/tensors.html#torch.Tensor>`_

Definition at line 137 of file geometric_layers.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
			nfeat_in_dim,
			efeat_in_dim,
			gfeat_in_dim,
			nfeat_hid_dim,
			nfeat_out_dim,
			num_hid_layers,
			dropout,
			normalize = True
	)

Initialization.

Definition at line 169 of file geometric_layers.py.

    ):
        """
        Initialization.
        """
        super(NodeLayer, self).__init__()
 
        
        self.nonlin_function = F.elu
        
        self.num_hid_layers = num_hid_layers
        
        self.dropout_prob = dropout
        
        self.normalize = normalize
 
        
        self.lin_in = nn.Linear(
            gfeat_in_dim + nfeat_in_dim + efeat_in_dim, nfeat_hid_dim
        )
        
        self.lins_hid = nn.ModuleList(
            [
                nn.Linear(nfeat_hid_dim, nfeat_hid_dim)
                for _ in range(self.num_hid_layers)
            ]
        )
        
        self.lin_out = nn.Linear(nfeat_hid_dim, nfeat_out_dim, bias=not normalize)
 
        if normalize:
            
            self.norm = nn.BatchNorm1d(nfeat_out_dim)
 
        _init_weights(self, normalize)
 

Member Function Documentation

forward()

def forward	(		self,
			x,
			edge_index,
			edge_attr,
			u,
			batch
	)

Called internally by PyTorch to propagate the input through the network.
 - x: [N, F_x], where N is the number of nodes.
 - edge_index: [2, E] with max entry N - 1.
 - edge_attr: [E, F_e]
 - u: [B, F_u]
 - batch: [N] with max entry B - 1.

Edge labels are averaged (dim_size = N: number of nodes in the graph)

Definition at line 214 of file geometric_layers.py.

    def forward(self, x, edge_index, edge_attr, u, batch):
        """
        Called internally by PyTorch to propagate the input through the network.
         - x: [N, F_x], where N is the number of nodes.
         - edge_index: [2, E] with max entry N - 1.
         - edge_attr: [E, F_e]
         - u: [B, F_u]
         - batch: [N] with max entry B - 1.
 
        Edge labels are averaged (dim_size = N: number of nodes in the graph)
        """
        out = scatter(
            edge_attr, edge_index[1], dim=0, dim_size=batch.size(0), reduce="mean"
        )
        out = (
            torch.cat([x, out, u[batch]], dim=1)
            if u.shape != torch.Size([0])
            else torch.cat([x, out], dim=1)
        )
 
        out = self.nonlin_function(self.lin_in(out))
        out = F.dropout(out, self.dropout_prob, training=self.training)
 
        out_skip = out
 
        for lin_hid in self.lins_hid:
            out = self.nonlin_function(lin_hid(out))
            out = F.dropout(out, self.dropout_prob, training=self.training)
 
        if self.num_hid_layers > 1:
            out += out_skip
 
        if self.normalize:
            out = self.nonlin_function(self.norm(self.lin_out(out)))
        else:
            out = self.nonlin_function(self.lin_out(out))
 
        return out
 
 

Member Data Documentation

dropout_prob

dropout_prob

Dropout probability.

Definition at line 190 of file geometric_layers.py.

lin_in

lin_in

Input linear layer.

Definition at line 195 of file geometric_layers.py.

lin_out

lin_out

Output linear layer.

Definition at line 206 of file geometric_layers.py.

lins_hid

lins_hid

Intermediate linear layers.

Definition at line 199 of file geometric_layers.py.

nonlin_function

nonlin_function

Non-linear activation.

Definition at line 186 of file geometric_layers.py.

norm

norm

Batch normalization.

Definition at line 210 of file geometric_layers.py.

normalize

normalize

Normalize.

Definition at line 192 of file geometric_layers.py.

num_hid_layers

num_hid_layers

Number of hidden layers.

Definition at line 188 of file geometric_layers.py.

---

The documentation for this class was generated from the following file:

• analysis/scripts/grafei/model/geometric_layers.py