def __init__(self, net_params):
super().__init__()
num_atom_type = net_params['num_atom_type']
num_bond_type = net_params['num_bond_type']
hidden_dim = net_params['hidden_dim']
out_dim = net_params['out_dim']
in_feat_dropout = net_params['in_feat_dropout']
dropout = net_params['dropout']
aggregator_type = net_params['sage_aggregator']
n_layers = net_params['L']
batch_norm = net_params['batch_norm']
residual = net_params['residual']
self.readout = net_params['readout']
self.embedding_h = nn.Embedding(num_atom_type, hidden_dim)
self.in_feat_dropout = nn.Dropout(in_feat_dropout)
self.layers = nn.ModuleList([
GraphSageLayer(hidden_dim, hidden_dim, F.relu, dropout,
aggregator_type, batch_norm, residual)
for _ in range(n_layers - 1)
])
self.layers.append(
GraphSageLayer(hidden_dim, out_dim, F.relu, dropout,
aggregator_type, batch_norm, residual))
self.MLP_layer = MLPReadout(out_dim,
1) # 1 out dim since regression problem
def __init__(self, net_params):
super().__init__()
in_dim = net_params['in_dim']
hidden_dim = net_params['hidden_dim']
out_dim = net_params['out_dim']
n_classes = net_params['n_classes']
in_feat_dropout = net_params['in_feat_dropout']
dropout = net_params['dropout']
aggregator_type = net_params['sage_aggregator']
n_layers = net_params['L']
batch_norm = net_params['batch_norm']
residual = net_params['residual']
self.readout = net_params['readout']
self.n_classes = n_classes
self.device = net_params['device']
self.embedding_h = nn.Linear(in_dim, hidden_dim)
self.in_feat_dropout = nn.Dropout(in_feat_dropout)
self.layers = nn.ModuleList([
GraphSageLayer(hidden_dim, hidden_dim, F.relu, dropout,
aggregator_type, batch_norm, residual)
for _ in range(n_layers - 1)
])
self.layers.append(
GraphSageLayer(hidden_dim, out_dim, F.relu, dropout,
aggregator_type, batch_norm, residual))
self.MLP_layer = MLPReadout(2 * out_dim, n_classes)
def __init__(self, net_params):
super().__init__()
in_dim_node = net_params['in_dim'] # node_dim (feat is an integer)
hidden_dim = net_params['hidden_dim']
out_dim = net_params['out_dim']
n_classes = net_params['n_classes']
in_feat_dropout = net_params['in_feat_dropout']
dropout = net_params['dropout']
aggregator_type = net_params['sage_aggregator']
n_layers = net_params['L']
self.readout = net_params['readout']
self.residual = net_params['residual']
self.n_classes = n_classes
self.device = net_params['device']
self.embedding_h = nn.Embedding(in_dim_node,
hidden_dim) # node feat is an integer
self.in_feat_dropout = nn.Dropout(in_feat_dropout)
self.layers = nn.ModuleList([
GraphSageLayer(hidden_dim, hidden_dim, F.relu, dropout,
aggregator_type, self.residual)
for _ in range(n_layers - 1)
])
self.layers.append(
GraphSageLayer(hidden_dim, out_dim, F.relu, dropout,
aggregator_type, self.residual))
self.MLP_layer = MLPReadout(out_dim, n_classes)
def __init__(self):
super().__init__()
self.L = 4
self.out_dim = 108
self.residual = True
self.in_dim = 32
self.hidden_dim = 108
self.n_classes = 10
self.in_feat_dropout = 0.0
self.sage_aggregator = "meanpool"
self.readout = "mean"
self.dropout = 0.0
self.embedding_h = nn.Linear(self.in_dim, self.hidden_dim)
self.in_feat_dropout = nn.Dropout(self.in_feat_dropout)
self.layers = nn.ModuleList([
GraphSageLayer(self.hidden_dim, self.hidden_dim, F.relu,
self.dropout, self.sage_aggregator, self.residual)
for _ in range(self.L - 1)
])
self.layers.append(
GraphSageLayer(self.hidden_dim, self.out_dim, F.relu, self.dropout,
self.sage_aggregator, self.residual))
self.readout_mlp = MLPReadout(self.out_dim, self.n_classes)
pass
def __init__(self,
in_dim=146,
hidden_dims=[108, 108, 108, 108],
out_dim=108,
n_classes=10):
super().__init__()
self.hidden_dims = hidden_dims
self.dropout = 0.0
self.residual = True
self.sage_aggregator = "meanpool"
self.embedding_h = nn.Linear(in_dim, self.hidden_dims[0])
_in_dim = self.hidden_dims[0]
self.gcn_list = nn.ModuleList()
for hidden_dim in self.hidden_dims[1:]:
self.gcn_list.append(
GraphSageLayer(_in_dim, hidden_dim, F.relu, self.dropout,
self.sage_aggregator, self.residual))
_in_dim = hidden_dim
pass
self.gcn_list.append(
GraphSageLayer(self.hidden_dims[-1], out_dim, F.relu, self.dropout,
self.sage_aggregator, self.residual))
self.readout_mlp = nn.Linear(out_dim, n_classes, bias=False)
pass
def __init__(self, net_params):
super().__init__()
num_node_type = net_params['num_node_type']
num_edge_type = net_params['num_edge_type']
hidden_dim = net_params['hidden_dim']
out_dim = net_params['out_dim']
n_classes = net_params['n_classes']
in_feat_dropout = net_params['in_feat_dropout']
dropout = net_params['dropout']
aggregator_type = net_params['sage_aggregator']
n_layers = net_params['L']
batch_norm = net_params['batch_norm']
residual = net_params['residual']
self.readout = net_params['readout']
self.pos_enc = net_params['pos_enc']
if self.pos_enc:
pos_enc_dim = net_params['pos_enc_dim']
self.embedding_pos_enc = nn.Linear(pos_enc_dim, hidden_dim)
else:
in_dim = 1
self.embedding_h = nn.Embedding(in_dim, hidden_dim)
self.in_feat_dropout = nn.Dropout(in_feat_dropout)
self.layers = nn.ModuleList([GraphSageLayer(hidden_dim, hidden_dim, F.relu,
dropout, aggregator_type, batch_norm, residual) for _ in range(n_layers-1)])
self.layers.append(GraphSageLayer(hidden_dim, out_dim, F.relu, dropout, aggregator_type, batch_norm, residual))
self.MLP_layer = MLPReadout(out_dim, n_classes)
def __init__(self, input_dim, assign_dim, output_feat_dim,
activation, dropout, aggregator_type, graph_norm, batch_norm, link_pred):
super().__init__()
self.embedding_dim = input_dim
self.assign_dim = assign_dim
self.hidden_dim = output_feat_dim
self.link_pred = link_pred
self.feat_gc = GraphSageLayer(
input_dim,
output_feat_dim,
activation,
dropout,
aggregator_type,
graph_norm,
batch_norm)
self.pool_gc = GraphSageLayer(
input_dim,
assign_dim,
activation,
dropout,
aggregator_type,
graph_norm,
batch_norm)
self.reg_loss = nn.ModuleList([])
self.loss_log = {}
self.reg_loss.append(EntropyLoss())
def __init__(self, net_params):
super().__init__()
in_dim = net_params['in_dim']
hidden_dim = net_params['hidden_dim']
out_dim = net_params['out_dim']
n_classes = net_params['n_classes']
in_feat_dropout = net_params['in_feat_dropout']
dropout = net_params['dropout']
aggregator_type = net_params['sage_aggregator']
n_layers = net_params['L']
self.residual = net_params['residual']
dgl_builtin = net_params['builtin']
bnorm = net_params['batch_norm']
self.layers = nn.ModuleList()
# Input
self.layers.append(
GraphSageLayer(in_dim,
hidden_dim,
F.relu,
dropout,
aggregator_type,
self.residual,
bn=bnorm,
dgl_builtin=dgl_builtin))
# Hidden layers
self.layers.extend(
nn.ModuleList([
GraphSageLayer(hidden_dim,
hidden_dim,
F.relu,
dropout,
aggregator_type,
self.residual,
bn=bnorm,
dgl_builtin=dgl_builtin)
for _ in range(n_layers - 1)
]))
# Output layer
self.layers.append(
GraphSageLayer(hidden_dim,
n_classes,
None,
dropout,
aggregator_type,
self.residual,
bn=bnorm,
dgl_builtin=dgl_builtin))
def __init__(self, in_dim, hidden_dims):
super().__init__()
self.gcn_list = nn.ModuleList()
for hidden_dim in hidden_dims:
self.gcn_list.append(GraphSageLayer(in_dim, hidden_dim, F.relu, 0.0, "meanpool", True))
in_dim = hidden_dim
pass
pass
def __init__(self, in_dim=64, hidden_dims=[108, 108], out_dim=108):
super().__init__()
self.hidden_dims = hidden_dims
assert 2 <= len(self.hidden_dims) <= 3
self.dropout = 0.0
self.residual = True
self.sage_aggregator = "meanpool"
self.embedding_h = nn.Linear(in_dim, self.hidden_dims[0])
self.graph_sage_1 = GraphSageLayer(self.hidden_dims[0], self.hidden_dims[1], F.relu,
self.dropout, self.sage_aggregator, self.residual)
if len(self.hidden_dims) >= 3:
self.graph_sage_2 = GraphSageLayer(self.hidden_dims[1], self.hidden_dims[2], F.relu,
self.dropout, self.sage_aggregator, self.residual)
pass
self.graph_sage_o = GraphSageLayer(self.hidden_dims[-1], out_dim, F.relu,
self.dropout, self.sage_aggregator, self.residual)
pass
def __init__(self, in_dim, hidden_dims, n_classes=10):
super().__init__()
self.embedding_h = nn.Linear(in_dim, in_dim)
self.gcn_list = nn.ModuleList()
for hidden_dim in hidden_dims:
self.gcn_list.append(GraphSageLayer(in_dim, hidden_dim, F.relu, 0.0, "meanpool", True))
in_dim = hidden_dim
pass
self.readout_mlp = nn.Linear(hidden_dims[-1], n_classes, bias=False)
pass
def __init__(self, in_dim=146, hidden_dims=[108, 108, 108, 108], out_dim=108, n_classes=10):
super().__init__()
self.hidden_dims = hidden_dims
assert 3 <= len(self.hidden_dims) <= 6
self.dropout = 0.0
self.residual = True
self.sage_aggregator = "meanpool"
self.embedding_h = nn.Linear(in_dim, self.hidden_dims[0])
self.graph_sage_1 = GraphSageLayer(self.hidden_dims[0], self.hidden_dims[1], F.relu,
self.dropout, self.sage_aggregator, self.residual)
self.graph_sage_2 = GraphSageLayer(self.hidden_dims[1], self.hidden_dims[2], F.relu,
self.dropout, self.sage_aggregator, self.residual)
if len(self.hidden_dims) >= 4:
self.graph_sage_3 = GraphSageLayer(self.hidden_dims[2], self.hidden_dims[3], F.relu,
self.dropout, self.sage_aggregator, self.residual)
if len(self.hidden_dims) >= 5:
self.graph_sage_4 = GraphSageLayer(self.hidden_dims[3], self.hidden_dims[4], F.relu,
self.dropout, self.sage_aggregator, self.residual)
if len(self.hidden_dims) >= 6:
self.graph_sage_5 = GraphSageLayer(self.hidden_dims[4], self.hidden_dims[5], F.relu,
self.dropout, self.sage_aggregator, self.residual)
self.graph_sage_o = GraphSageLayer(self.hidden_dims[-1], out_dim, F.relu,
self.dropout, self.sage_aggregator, self.residual)
self.readout_mlp = MLPReadout(out_dim, n_classes)
pass
def __init__(self, in_dim, hidden_dims, readout="mean"):
super().__init__()
self.in_dim = in_dim
self.hidden_dims = hidden_dims
self.readout = readout
self.gcn_list = nn.ModuleList()
_in_dim = self.in_dim
for hidden_dim in hidden_dims:
self.gcn_list.append(
GraphSageLayer(_in_dim, hidden_dim, F.relu, 0.0, "meanpool",
True))
_in_dim = hidden_dim
pass
Tools.print(
"GraphSageNet1 #GNN1={} in_dim={} hidden_dims={} readout={}".
format(len(self.hidden_dims), self.in_dim, self.hidden_dims,
self.readout))
pass
def __init__(self, in_dim, hidden_dims, skip_which, skip_dim=128, n_out=1):
super().__init__()
self.embedding_h = nn.Linear(in_dim, in_dim)
_in_dim = in_dim
self.gcn_list = nn.ModuleList()
for hidden_dim in hidden_dims:
self.gcn_list.append(GraphSageLayer(_in_dim, hidden_dim, F.relu, 0.0, "meanpool", True))
_in_dim = hidden_dim
pass
sk_hidden_dims = [in_dim] + [hidden_dims[which-1] for which in skip_which]
self.skip_connect_index = [0] + skip_which
self.skip_connect_list = nn.ModuleList()
for hidden_dim in sk_hidden_dims:
self.skip_connect_list.append(nn.Linear(hidden_dim, skip_dim, bias=False))
pass
self.readout = nn.Linear(len(self.skip_connect_list) * skip_dim, n_out, bias=False)
pass
def __init__(self, in_dim, hidden_dims, n_classes=10, readout="mean"):
super().__init__()
self.in_dim = in_dim
self.hidden_dims = hidden_dims
self.readout = readout
self.embedding_h = nn.Linear(in_dim, in_dim)
self.gcn_list = nn.ModuleList()
_in_dim = self.in_dim
for hidden_dim in hidden_dims:
self.gcn_list.append(
GraphSageLayer(_in_dim, hidden_dim, F.relu, 0.0, "meanpool",
True))
_in_dim = hidden_dim
pass
self.readout_mlp = nn.Linear(hidden_dims[-1], n_classes, bias=False)
Tools.print(
"GraphSageNet2 #GNN2={} in_dim={} hidden_dims={} readout={}".
format(len(self.hidden_dims), self.in_dim, self.hidden_dims,
self.readout))
pass
def __init__(self, net_params):
super().__init__()
num_atom_type = net_params['num_atom_type']
num_bond_type = net_params['num_bond_type']
hidden_dim = net_params['hidden_dim']
out_dim = net_params['out_dim']
in_feat_dropout = net_params['in_feat_dropout']
dropout = net_params['dropout']
aggregator_type = net_params['sage_aggregator']
n_layers = net_params['L']
self.graph_norm = net_params['graph_norm']
self.batch_norm = net_params['batch_norm']
self.layer_norm = net_params['layer_norm']
self.readout = net_params['readout']
self.residual = net_params['residual']
self.concat_norm = net_params['concat_norm']
self.task = net_params['task']
if self.task == 'classification':
self.num_classes = net_params['num_classes']
else:
self.num_classes = 1
self.embedding_lin = nn.Linear(num_atom_type, hidden_dim, bias=False)
self.in_feat_dropout = nn.Dropout(in_feat_dropout)
self.layers = nn.ModuleList([
GraphSageLayer(hidden_dim, hidden_dim, F.relu, dropout,
aggregator_type, self.batch_norm, self.graph_norm,
self.layer_norm, self.concat_norm)
for _ in range(n_layers)
])
self.linear_ro = nn.Linear(hidden_dim, out_dim, bias=False)
self.linear_predict = nn.Linear(out_dim, self.num_classes, bias=True)
# additional parameters for gated residual connection
if self.residual == "gated":
self.W_g = nn.Linear(2 * hidden_dim, hidden_dim, False)
def __init__(self, net_params):
super().__init__()
input_dim = net_params['in_dim']
hidden_dim = net_params['hidden_dim']
embedding_dim = net_params['embedding_dim']
label_dim = net_params['n_classes']
activation = F.relu
n_layers = net_params['L'] # this is the gnn_per_block param
dropout = net_params['dropout']
self.graph_norm = net_params['graph_norm']
self.batch_norm = net_params['batch_norm']
self.residual = net_params['residual']
aggregator_type = net_params['sage_aggregator']
pool_ratio = net_params['pool_ratio']
self.device = net_params['device']
self.link_pred = net_params['linkpred']
self.concat = net_params['cat']
self.n_pooling = net_params['num_pool']
self.batch_size = net_params['batch_size']
self.link_pred_loss = []
self.entropy_loss = []
self.embedding_h = nn.Linear(input_dim, hidden_dim)
# list of GNN modules before the first diffpool operation
self.gc_before_pool = nn.ModuleList()
self.assign_dim = net_params['assign_dim']
# self.bn = True
self.num_aggs = 1
# constructing layers
# layers before diffpool
assert n_layers >= 3, "n_layers too few"
self.gc_before_pool.append(
GraphSageLayer(hidden_dim, hidden_dim, activation, dropout,
aggregator_type, self.graph_norm, self.batch_norm,
self.residual))
for _ in range(n_layers - 2):
self.gc_before_pool.append(
GraphSageLayer(hidden_dim, hidden_dim, activation, dropout,
aggregator_type, self.graph_norm,
self.batch_norm, self.residual))
self.gc_before_pool.append(
GraphSageLayer(hidden_dim, embedding_dim, None, dropout,
aggregator_type, self.graph_norm, self.batch_norm,
self.residual))
assign_dims = []
assign_dims.append(self.assign_dim)
if self.concat:
# diffpool layer receive pool_emedding_dim node feature tensor
# and return pool_embedding_dim node embedding
pool_embedding_dim = hidden_dim * (n_layers - 1) + embedding_dim
else:
pool_embedding_dim = embedding_dim
self.first_diffpool_layer = DiffPoolLayer(
pool_embedding_dim, self.assign_dim, hidden_dim, activation,
dropout, aggregator_type, self.graph_norm, self.batch_norm,
self.link_pred)
gc_after_per_pool = nn.ModuleList()
# list of list of GNN modules, each list after one diffpool operation
self.gc_after_pool = nn.ModuleList()
for _ in range(n_layers - 1):
gc_after_per_pool.append(
DenseGraphSage(hidden_dim, hidden_dim, self.residual))
gc_after_per_pool.append(
DenseGraphSage(hidden_dim, embedding_dim, self.residual))
self.gc_after_pool.append(gc_after_per_pool)
self.assign_dim = int(self.assign_dim * pool_ratio)
self.diffpool_layers = nn.ModuleList()
# each pooling module
for _ in range(self.n_pooling - 1):
self.diffpool_layers.append(
DenseDiffPool(pool_embedding_dim, self.assign_dim, hidden_dim,
self.link_pred))
gc_after_per_pool = nn.ModuleList()
for _ in range(n_layers - 1):
gc_after_per_pool.append(
DenseGraphSage(hidden_dim, hidden_dim, self.residual))
gc_after_per_pool.append(
DenseGraphSage(hidden_dim, embedding_dim, self.residual))
self.gc_after_pool.append(gc_after_per_pool)
assign_dims.append(self.assign_dim)
self.assign_dim = int(self.assign_dim * pool_ratio)
# predicting layer
if self.concat:
self.pred_input_dim = pool_embedding_dim * \
self.num_aggs * (n_pooling + 1)
else:
self.pred_input_dim = embedding_dim * self.num_aggs
self.pred_layer = nn.Linear(self.pred_input_dim, label_dim)
# weight initialization
for m in self.modules():
if isinstance(m, nn.Linear):
m.weight.data = init.xavier_uniform_(
m.weight.data, gain=nn.init.calculate_gain('relu'))
if m.bias is not None:
m.bias.data = init.constant_(m.bias.data, 0.0)
def __init__(self, net_params):
super().__init__()
self.device = net_params.device
self.concat = net_params.cat
self.batch_size = net_params.batch_size
self.link_pred_loss = []
self.entropy_loss = []
self.embedding_h = nn.Linear(net_params.in_dim, net_params.hidden_dim)
# list of GNN modules before the first diffpool operation
self.gc_before_pool = nn.ModuleList()
self.bn = True
self.num_aggs = 1
# constructing layers
# layers before diffpool
assert net_params.L >= 3, "n_layers too few"
self.gc_before_pool.append(GraphSageLayer(
net_params.hidden_dim, net_params.hidden_dim, F.relu,
net_params.dropout, net_params.sage_aggregator, net_params.residual, self.bn))
for _ in range(net_params.L - 2):
self.gc_before_pool.append(GraphSageLayer(
net_params.hidden_dim, net_params.hidden_dim, F.relu,
net_params.dropout, net_params.sage_aggregator, net_params.residual, self.bn))
pass
self.gc_before_pool.append(GraphSageLayer(
net_params.hidden_dim, net_params.embedding_dim, None,
net_params.dropout, net_params.sage_aggregator, net_params.residual))
assign_dims = [net_params.assign_dim]
if self.concat:
# diffpool layer receive pool_emedding_dim node feature tensor and return pool_embedding_dim node embedding
pool_embedding_dim = net_params.hidden_dim * (net_params.L - 1) + net_params.embedding_dim
else:
pool_embedding_dim = net_params.embedding_dim
pass
self.first_diffpool_layer = DiffPoolLayer(
pool_embedding_dim, net_params.assign_dim, net_params.hidden_dim,
F.relu, net_params.dropout, net_params.sage_aggregator, net_params.linkpred)
gc_after_per_pool = nn.ModuleList()
for _ in range(net_params.L - 1):
gc_after_per_pool.append(DenseGraphSage(net_params.hidden_dim, net_params.hidden_dim, net_params.residual))
gc_after_per_pool.append(DenseGraphSage(net_params.hidden_dim, net_params.embedding_dim, net_params.residual))
self.gc_after_pool = nn.ModuleList()
self.gc_after_pool.append(gc_after_per_pool)
net_params.assign_dim = int(net_params.assign_dim * net_params.pool_ratio)
self.diffpool_layers = nn.ModuleList()
for _ in range(net_params.num_pool - 1):
self.diffpool_layers.append(DenseDiffPool(pool_embedding_dim, net_params.assign_dim,
net_params.hidden_dim, net_params.linkpred))
gc_after_per_pool = nn.ModuleList()
for _ in range(net_params.L - 1):
gc_after_per_pool.append(DenseGraphSage(net_params.hidden_dim,
net_params.hidden_dim, net_params.residual))
pass
gc_after_per_pool.append(DenseGraphSage(net_params.hidden_dim,
net_params.embedding_dim, net_params.residual))
self.gc_after_pool.append(gc_after_per_pool)
assign_dims.append(net_params.assign_dim)
net_params.assign_dim = int(net_params.assign_dim * net_params.pool_ratio)
pass
# predicting layer
if self.concat:
self.pred_input_dim = pool_embedding_dim * self.num_aggs * (net_params.num_pool + 1)
else:
self.pred_input_dim = net_params.embedding_dim * self.num_aggs
self.pred_layer = nn.Linear(self.pred_input_dim, net_params.n_classes)
# weight initialization
for m in self.modules():
if isinstance(m, nn.Linear):
m.weight.data = init.xavier_uniform_(m.weight.data, gain=nn.init.calculate_gain('relu'))
if m.bias is not None:
m.bias.data = init.constant_(m.bias.data, 0.0)
pass
pass
pass
