def __init__(self, num_feats=None, dims=None, num_classes=2, message_passing='GCN', GCN_improved=False,
GAT_heads=None, skip=True):
super(PiNet, self).__init__()
if dims is None:
dims = [64, 64]
self.skip = skip
if message_passing == 'GCN':
from torch_geometric.nn import GCNConv
self.mp_a1 = GCNConv(num_feats, dims[0], improved=GCN_improved)
self.mp_x1 = GCNConv(num_feats, dims[0], improved=GCN_improved)
skip_dims = dims[0] + num_feats if skip else dims[0]
self.linear_a = torch.nn.Linear(skip_dims, dims[0])
self.linear_x = torch.nn.Linear(skip_dims, dims[0])
self.mp_a2 = GCNConv(dims[0], dims[1], improved=GCN_improved)
self.mp_x2 = GCNConv(dims[0], dims[1], improved=GCN_improved)
skip_dims2 = dims[1] + dims[0] if skip else dims[1]
self.linear2 = torch.nn.Linear(skip_dims2 ** 2, num_classes)
elif message_passing == 'GAT':
from torch_geometric.nn import GATConv
if (GAT_heads == None):
GAT_heads = [5, 2]
self.mp_a1 = GATConv(num_feats, dims[0], heads=GAT_heads[0])
self.mp_x1 = GATConv(num_feats, dims[0], heads=GAT_heads[0])
skip_dims = (dims[0] * GAT_heads[0]) + num_feats if skip else dims[0] * GAT_heads[0]
self.linear_a = torch.nn.Linear(skip_dims, dims[0])
self.linear_x = torch.nn.Linear(skip_dims, dims[0])
self.mp_a2 = GATConv(dims[0] if skip else dims[0] * GAT_heads[0], dims[1], heads=GAT_heads[1])
self.mp_x2 = GATConv(dims[0] if skip else dims[0] * GAT_heads[0], dims[1], heads=GAT_heads[1])
skip_dims2 = (dims[1] * GAT_heads[1]) + dims[0] if skip else dims[1] * GAT_heads[1]
self.linear2 = torch.nn.Linear(skip_dims2 ** 2, num_classes)
elif message_passing == 'SAGE':
from torch_geometric.nn import SAGEConv
self.mp_a1 = SAGEConv(num_feats, dims[0])
self.mp_x1 = SAGEConv(num_feats, dims[0])
skip_dims = dims[0] + num_feats if skip else dims[0]
self.linear_a = torch.nn.Linear(skip_dims, dims[0])
self.linear_x = torch.nn.Linear(skip_dims, dims[0])
self.mp_a2 = SAGEConv(dims[0], dims[1])
self.mp_x2 = SAGEConv(dims[0], dims[1])
skip_dims2 = dims[1] + dims[0] if skip else dims[1]
self.linear2 = torch.nn.Linear(skip_dims2 ** 2, num_classes)
def __init__(self, dataset, num_layers, hidden):
super(GlobalAttentionNet, self).__init__()
self.conv1 = SAGEConv(dataset.num_features, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(SAGEConv(hidden, hidden))
self.att = GlobalAttention(Linear(hidden, 1))
self.lin1 = Linear(hidden, hidden)
self.lin2 = Linear(hidden, dataset.num_classes)
def __init__(self, dataset, num_layers, hidden):
super().__init__()
self.conv1 = SAGEConv(dataset.num_features, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(SAGEConv(hidden, hidden))
self.set2set = Set2Set(hidden, processing_steps=4)
self.lin1 = Linear(2 * hidden, hidden)
self.lin2 = Linear(hidden, dataset.num_classes)
def __init__(self, in_channels, opts):
super(FAE_SAGEConv, self).__init__()
self.opts = opts
if self.opts.problem == 'Prediction':
self.conv1 = SAGEConv(in_channels, 64)
self.conv2 = SAGEConv(64, 32)
self.lin = Lin(32, 1)
else:
self.conv1 = SAGEConv(in_channels, 64)
self.lin = Lin(64, in_channels)
def __init__(self, input_channels, hidden_channels, out_channels, num_layers=3, dropout_ratio=0., aggr='mean'):
super().__init__()
torch.manual_seed(1234567)
self.num_layers = num_layers
self.dropout_ratio = dropout_ratio
self.convs = nn.ModuleList()
self.convs.append(SAGEConv(input_channels, hidden_channels, aggr=aggr))
for i in range(num_layers-2):
self.convs.append(SAGEConv(hidden_channels,hidden_channels, aggr=aggr))
self.convs.append(SAGEConv(hidden_channels, out_channels, aggr=aggr))
def __init__(self, dataset, num_layers, hidden):
super(GraphSAGE, self).__init__()
self.conv1 = SAGEConv(dataset.num_features, hidden)
#self.conv1 = SAGELafConv(dataset.num_features, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 2):
#self.convs.append(SAGEConv(hidden, hidden))
self.convs.append(SAGELafConv(hidden, hidden))
#self.convn = SAGELafConv(hidden, dataset.num_classes)
self.convn = SAGEConv(hidden, dataset.num_classes)
def __init__(self, in_channels, hidden_channels, out_channels, num_layers):
super(SAGE, self).__init__()
self.num_layers = num_layers
self.convs = torch.nn.ModuleList()
self.convs.append(SAGEConv(in_channels, hidden_channels))
for _ in range(num_layers - 2):
self.convs.append(SAGEConv(hidden_channels, hidden_channels))
self.convs.append(SAGEConv(hidden_channels, out_channels))
def __init__(self, input_dim, out_dim, filter_num, dropout=False, layer=2):
super(SAGEModel, self).__init__()
self.dropout = dropout
self.conv1 = SAGEConv(input_dim, filter_num)
self.conv2 = SAGEConv(filter_num, filter_num)
self.Conv = nn.Conv1d(filter_num, out_dim, kernel_size=1)
self.layer = layer
if layer == 3:
self.conv3 = SAGEConv(filter_num, filter_num)
def __init__(self, in_channels, hidden_channels, output_dim, num_layers):
super(SortPool, self).__init__()
self.k = 30
self.conv1 = SAGEConv(in_channels, hidden_channels)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(SAGEConv(hidden_channels, hidden_channels))
self.conv1d = Conv1d(hidden_channels, 32, 5)
self.lin1 = Linear(32 * (self.k - 5 + 1), hidden_channels)
self.lin2 = Linear(hidden_channels, output_dim)
def __init__(self, dataset, num_layers, hidden):
super().__init__()
self.k = 30
self.conv1 = SAGEConv(dataset.num_features, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(SAGEConv(hidden, hidden))
self.conv1d = Conv1d(hidden, 32, 5)
self.lin1 = Linear(32 * (self.k - 5 + 1), hidden)
self.lin2 = Linear(hidden, dataset.num_classes)
def __init__(self, in_channels, hidden_channels, out_channels, num_layers):
super(Net, self).__init__()
self.convs = torch.nn.ModuleList()
self.batch_norms = torch.nn.ModuleList()
self.convs.append(SAGEConv(in_channels, hidden_channels))
self.batch_norms.append(BatchNorm(hidden_channels))
for _ in range(num_layers - 2):
self.convs.append(SAGEConv(hidden_channels, hidden_channels))
self.batch_norms.append(BatchNorm(hidden_channels))
self.convs.append(SAGEConv(hidden_channels, out_channels))
def __init__(self, dim_features, dim_embedding):
super(Encoder, self).__init__()
#self.conv = SAGEConv(dim_features, dim_embedding)
#self.prelu = nn.PReLU(dim_embedding)
self.prelu = nn.PReLU() # like in Repository
self.gcn1 = SAGEConv(dim_features, dim_embedding, normalize=True)
self.gcn2 = SAGEConv(dim_embedding, dim_embedding, normalize=True)
self.gcn3 = SAGEConv(dim_embedding, dim_embedding, normalize=True)
self.Wskip = Linear(dim_features, dim_embedding)
def __init__(self, data, num_classes, args):
super(GraphSAGE, self).__init__()
self.args = args
self.data = data
self.conv1 = SAGEConv(self.data.num_features,
self.args.sage_hidden,
normalize=False)
self.conv2 = SAGEConv(self.args.sage_hidden,
num_classes,
normalize=False)
def __init__(self, input_dim, hidden_dim):
super(MetaNet, self).__init__()
self.conv1 = SAGEConv(input_dim, hidden_dim)
self.drop1 = nn.Dropout(p=0.1)
self.conv2 = SAGEConv(hidden_dim, hidden_dim)
self.drop2 = nn.Dropout(p=0.1)
self.lin = nn.Linear(hidden_dim * 2, 1)
def __init__(self, n_features):
super(SageNet, self).__init__()
self.conv1 = SAGEConv(n_features, 16, normalize=False)
self.conv2 = SAGEConv(16, 16, normalize=False)
self.conv3 = SAGEConv(16, 16, normalize=False)
self.conv4 = SAGEConv(16, 16, normalize=False)
self.conv5 = SAGEConv(16, 16, normalize=False)
self.conv6 = SAGEConv(16, 16, normalize=False)
self.conv7 = SAGEConv(16, 16, normalize=False)
self.conv8 = SAGEConv(16, 16, normalize=False)
self.conv9 = SAGEConv(16, 16, normalize=False)
self.lin1 = Linear(16, 64)
self.lin2 = Linear(64, 16)
self.out = Linear(16, 1)
self.s1 = SELU()
self.s2 = SELU()
self.s3 = SELU()
self.s4 = SELU()
self.s5 = SELU()
self.s6 = SELU()
self.s7 = SELU()
self.s8 = SELU()
self.s9 = SELU()
self.s10 = SELU()
self.s11 = SELU()
def __init__(self, in_channels, cls_num):
super(Net, self).__init__()
# self.conv1 = GCNConv(in_channels, 64)
# self.conv2 = GCNConv(64, 32)
# self.conv3 = GCNConv(32, cls_num+1)
self.conv1 = SAGEConv(in_channels, 64)
self.bn1 = nn.BatchNorm1d(64)
self.conv2 = SAGEConv(64, 32)
self.bn2 = nn.BatchNorm1d(32)
self.conv3 = SAGEConv(32, cls_num)
def __init__(self, dataset, device,loss_function,mode='unsupervised',conv='GCN',hidden_layer=64,out_layer =128,dropout = 0,num_layers=2):
super(Net, self).__init__()
self.mode = mode
self.conv=conv
self.num_layers = num_layers
self.data = dataset
self.num_features = dataset.x.shape[1]
#print(dataset.num_features)
self.loss_function = loss_function
self.convs = torch.nn.ModuleList()
self.hidden_layer =hidden_layer
self.out_layer = out_layer
self.dropout = dropout
self.device=device
if self.mode=='unsupervised':
out_channels = self.out_layer
elif self.mode=='supervised':
out_channels =len(collections.Counter(self.data.y.tolist()).keys()) #128 FOR LINK PREDICTION, FOR NODE CLASSIFICATION UNCOMMENT
if self.conv == 'GCN':
if self.num_layers == 1:
self.convs.append(GCNConv(self.num_features, out_channels))
else:
self.convs.append(GCNConv(self.num_features, self.hidden_layer))
for i in range(1,self.num_layers-1):
self.convs.append(GCNConv(self.hidden_layer, self.hidden_layer))
self.convs.append(GCNConv(self.hidden_layer, out_channels))
elif self.conv == 'SAGE':
if self.num_layers == 1:
self.convs.append(SAGEConv(self.num_features, out_channels))
else:
self.convs.append(SAGEConv(self.num_features, self.hidden_layer))
for i in range(1,self.num_layers-1):
self.convs.append(SAGEConv(self.hidden_layer, self.hidden_layer))
self.convs.append(SAGEConv(self.hidden_layer, out_channels))
elif self.conv == 'GAT':
if self.num_layers == 1:
self.convs.append(GATConv(self.num_features, out_channels))
else:
self.convs.append(GATConv(self.num_features, self.hidden_layer))
for i in range(1,self.num_layers-1):
self.convs.append(GATConv(self.hidden_layer, self.hidden_layer))
self.convs.append(GATConv(self.hidden_layer, out_channels))
if loss_function["loss var"] == "Random Walks":
self.loss = self.lossRandomWalks
elif loss_function["loss var"] == "Context Matrix":
self.loss = self.lossContextMatrix
elif loss_function["loss var"] == "Factorization":
self.loss = self.lossFactorization
elif loss_function["loss var"] == "Laplacian EigenMaps":
self.loss = self.lossLaplacianEigenMaps
self.reset_parameters()
def __init__(self, num_node_features, num_of_classes=2):
super(Net_1, self).__init__()
self.conv1 = SAGEConv(num_node_features, 128)
self.pool1 = TopKPooling(128, ratio=0.5)
self.conv2 = SAGEConv(128, 128)
self.pool2 = TopKPooling(128, ratio=0.5)
self.conv3 = SAGEConv(128, 128)
self.pool3 = TopKPooling(128, ratio=0.5)
self.lin1 = torch.nn.Linear(256, 128)
self.lin2 = torch.nn.Linear(128, 64)
self.lin3 = torch.nn.Linear(64, num_of_classes)
def __init__(self, dataset, num_layers, hidden, mode='cat'):
super().__init__()
self.conv1 = SAGEConv(dataset.num_features, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(SAGEConv(hidden, hidden))
self.jump = JumpingKnowledge(mode)
if mode == 'cat':
self.lin1 = Linear(num_layers * hidden, hidden)
else:
self.lin1 = Linear(hidden, hidden)
self.lin2 = Linear(hidden, dataset.num_classes)
def __init__(self):
super(Conv, self).__init__()
self.conv1 = nn.Conv2d(5, 32, 3, padding=1)
self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
self.conv3 = nn.Conv2d(64, 128, 3, padding=1)
self.conv4 = nn.Conv2d(128, 256, 3, padding=1)
self.conv5 = nn.Conv2d(256, 256, 3, padding=1)
#self.sagpool = SAGPooling(256, ratio=0.8,min_score=None)
self.sage1 = SAGEConv(256, 128, bias=True, normalize=True)
self.sage2 = SAGEConv(256, 128, bias=True, normalize=True)
self.sage3 = SAGEConv(128, 2, bias=True, normalize=True)
def __init__(self, feature, out_channel):
super(GraphSage, self).__init__()
self.GConv1 = SAGEConv(feature, 1024)
self.bn1 = BatchNorm(1024)
self.GConv2 = SAGEConv(1024, 1024)
self.bn2 = BatchNorm(1024)
self.fc = nn.Sequential(nn.Linear(1024, 512), nn.ReLU(inplace=True))
self.dropout = nn.Dropout(0.2)
self.fc1 = nn.Sequential(nn.Linear(512, out_channel))
def __init__(self, num_input_features, num_layers, hidden, mode='cat'):
super(GraphSAGEWithJK, self).__init__()
self.conv1 = SAGEConv(num_input_features, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(SAGEConv(hidden, hidden))
self.jump = JumpingKnowledge(mode)
if mode == 'cat':
self.lin1 = Linear(3 * num_layers * hidden, hidden)
else:
self.lin1 = Linear(3 * hidden, hidden)
self.lin2 = Linear(hidden, 2)
def __init__(self, in_dim, out_dim, hidden_dim, layers, dropout=0):
super().__init__()
assert layers >= 2
self.dropout = dropout
self.conv_layers = nn.ModuleList(
[SAGEConv(in_dim, hidden_dim, normalize=True)])
for _ in range(layers - 2):
self.conv_layers.append(
SAGEConv(hidden_dim, hidden_dim, normalize=True))
self.conv_layers.append(SAGEConv(hidden_dim, out_dim, normalize=True))
self.bn_layers = nn.ModuleList(
[BatchNorm(hidden_dim) for _ in range(layers-1)])
def __init__(self, in_channels, hidden_channels, out_channels, num_layers,
dropout):
super(SAGE, self).__init__()
self.convs = torch.nn.ModuleList()
self.convs.append(SAGEConv(in_channels, hidden_channels, concat=True))
for _ in range(num_layers - 2):
self.convs.append(
SAGEConv(hidden_channels, hidden_channels, concat=True))
self.convs.append(SAGEConv(hidden_channels, out_channels, concat=True))
self.dropout = dropout
def __init__(self, in_feats, hidden_dim, num_classes, num_layers, out_channel, kernel_size, k=30, dropout=0.5):
super(SortPool, self).__init__()
self.k = k
self.dropout = dropout
self.num_layers = num_layers
self.gnn_convs = nn.ModuleList()
self.gnn_convs.append(SAGEConv(in_feats, hidden_dim))
for _ in range(self.num_layers - 1):
self.gnn_convs.append(SAGEConv(hidden_dim, hidden_dim))
self.conv1d = nn.Conv1d(hidden_dim, out_channel, kernel_size)
self.fc1 = nn.Linear(out_channel * (self.k - kernel_size + 1), hidden_dim)
self.fc2 = nn.Linear(hidden_dim, num_classes)
def __init__(self, in_channels, hidden_channels, out_channels, num_layers,
dropout):
super(GCN, self).__init__()
self.inProj = torch.nn.Linear(in_channels, hidden_channels)
self.convs = torch.nn.ModuleList()
for _ in range(num_layers):
self.convs.append(SAGEConv(hidden_channels, hidden_channels))
self.convs.append(SAGEConv(hidden_channels, out_channels))
self.linear = torch.nn.Linear(hidden_channels, out_channels)
self.weights = torch.nn.Parameter(torch.randn((len(self.convs))))
self.dropout = dropout
def __init__(self,
num_features,
output_channels,
num_layers=3,
hidden=128,
**kwargs):
super(GraphSAGE, self).__init__()
self.conv1 = SAGEConv(num_features, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(SAGEConv(hidden, hidden))
self.lin1 = Linear(hidden, hidden)
self.lin2 = Linear(hidden, output_channels)
def __init__(self, num_node_features, hidden_channels, embed_dim=64):
super(Net, self).__init__()
self.device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
in_channels = num_node_features
out_channels = embed_dim
self.decoder = InnerProductDecoder().to(self.device)
self.conv1 = SAGEConv(in_channels, hidden_channels)
self.conv2 = SAGEConv(hidden_channels, hidden_channels)
self.conv3 = SAGEConv(hidden_channels, hidden_channels)
#self.lin = torch.nn.Linear(3 * hidden_channels, out_channels)
self.lin = torch.nn.Linear(hidden_channels, out_channels)
self.linear_decoder1 = torch.nn.Linear(1, 1)
def __init__(self,
features_num=16,
num_class=2,
num_layers=2,
hidden=128,
dropout=0.3):
super(GraphSAGE, self).__init__()
self.conv1 = SAGEConv(features_num, hidden)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 2):
self.convs.append(SAGEConv(hidden, hidden))
self.conv_last = SAGEConv(hidden, num_class)
self.dropout = dropout
def __init__(self):
super(Net, self).__init__()
self.conv1 = SAGEConv(dataset.num_features, 128)
self.pool1 = TopKPooling(128, ratio=0.8)
self.conv2 = SAGEConv(128, 128)
self.pool2 = TopKPooling(128, ratio=0.8)
self.conv3 = SAGEConv(128, 128)
self.pool3 = TopKPooling(128, ratio=0.8)
self.lin1 = torch.nn.Linear(256, 128)
self.lin2 = torch.nn.Linear(128, 64)
self.lin3 = torch.nn.Linear(64, dataset.num_classes)
