def __init__(self,B_s,Node_Dim,Hidden_Dim,Out_Dim,Class_Dim,Loss_Only=True): super(GNN,self).__init__() self.loss_only = Loss_Only self.Bs = B_s self.Conv1 = SAGEConv(Node_Dim,Hidden_Dim) self.Conv2 = SAGEConv(Hidden_Dim,Out_Dim) self.ClassHead = Linear(Out_Dim,Class_Dim)
def __init__(self, in_channels, out_channels, hidden_channels=256, n_layers=3, dropout=0.0, kwargs={}): super(SageNet, self).__init__() self.in_channels = in_channels self.out_channels = out_channels self.hidden_channels = hidden_channels self.n_layers = n_layers self.dropout = dropout self.kwargs = kwargs self.convs = nn.ModuleList() for i in range(self.n_layers - 1): n_in = self.in_channels if i == 0 else self.hidden_channels self.convs.append( SAGEConv( n_in, self.hidden_channels, aggr='add', normalize=True, # otherwise explode root_weight=False, **self.kwargs)) # Last layer self.convs.append( SAGEConv( self.hidden_channels, self.out_channels, aggr='add', normalize=True, # otherwise explode root_weight=False, **self.kwargs))
class SortPool(torch.nn.Module): 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 reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.conv1d.reset_parameters() self.lin1.reset_parameters() self.lin2.reset_parameters() def forward(self, x, edge_index, batch): # x, edge_index, batch = data.x, data.edge_index, data.batch x = F.relu(self.conv1(x, edge_index)) for conv in self.convs: x = F.relu(conv(x, edge_index)) x = global_sort_pool(x, batch, self.k) x = x.view(len(x), self.k, -1).permute(0, 2, 1) x = F.relu(self.conv1d(x)) x = x.view(len(x), -1) x = F.relu(self.lin1(x)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return x
def __init__(self, node_in_dim,node_out_dim=64, heads=1, dropout=0.1 ): super(GraphSAGE, self).__init__() self.conv1 = SAGEConv(node_in_dim, node_out_dim) self.conv2 = SAGEConv(node_out_dim, node_out_dim)
class Net(torch.nn.Module): def __init__(self): super(Net, self).__init__() hidden = args.hidden num_layers = 5 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 reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.set2set.reset_parameters() self.lin1.reset_parameters() self.lin2.reset_parameters() def forward(self, data): x, edge_index, batch = data.x, data.edge_index, data.batch x = F.relu(self.conv1(x, edge_index)) for conv in self.convs: x = F.relu(conv(x, edge_index)) x = self.set2set(x, batch) x = F.relu(self.lin1(x)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return F.log_softmax(x, dim=-1)
class SortPool(torch.nn.Module): def __init__(self, dataset, num_layers, hidden, num_classes): super(SortPool, self).__init__() self.k = 10 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.lin1 = nn.Linear(self.k * hidden, hidden) self.lin2 = nn.Linear(hidden, num_classes) def reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.lin1.reset_parameters() self.lin2.reset_parameters() def forward(self, data): x, edge_index, batch = data.x, data.edge_index, data.batch x = F.relu(self.conv1(x, edge_index)) for conv in self.convs: x = F.relu(conv(x, edge_index)) x = global_sort_pool(x, batch, self.k) x = F.relu(self.lin1(x)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return F.log_softmax(x, dim=-1) def __repr__(self): return self.__class__.__name__
class SAGE(torch.nn.Module): #已精调 def __init__(self, num_layers=2, hidden=32, features_num=32, num_class=2): super(SAGE, self).__init__() self.conv1 = SAGEConv(hidden, hidden) self.conv2 = SAGEConv(hidden, hidden) self.out = Linear(hidden * 3, num_class) self.first_lin = Linear(features_num, hidden) self.fuse_weight = torch.nn.Parameter(torch.FloatTensor(num_layers),requires_grad=True) self.fuse_weight.data.fill_(float(1) / (num_layers + 1)) def reset_parameters(self): self.first_lin.reset_parameters() self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.lin2.reset_parameters() def forward(self, data): x, edge_index, edge_weight = data.x, data.edge_index, data.edge_weight x = F.relu(self.first_lin(x)) x = F.dropout(x, p=0.5, training=self.training) xx = x x = self.conv1(x, edge_index, edge_weight) x = F.dropout(x, p=0.2, training=self.training) xx = torch.cat([xx, x], dim=1) x = self.conv2(x, edge_index, edge_weight) x = F.dropout(x, p=0.2, training=self.training) xx = torch.cat([xx, x], dim=1) x = self.out(xx) return F.log_softmax(x, dim=-1)
def __init__(self): super(GraphCluster, self).__init__() n_layers = 7 in_channels = 128 hidden_channels = 64 class_num = 18 bias = True normalize = False # self.embedding = nn.Sequential(nn.Linear(100, in_channels), # nn.ReLU(), ) self.layers.append( SAGEConv(in_channels, hidden_channels, normalize=normalize, bias=bias)) # hidden layers for i in range(n_layers - 1): self.layers.append( SAGEConv(hidden_channels, hidden_channels, normalize=normalize, bias=bias)) # output layer self.out_layer = SAGEConv(hidden_channels, class_num, normalize=normalize, bias=bias)
class GraphSAGE(torch.nn.Module): 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 reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.lin1.reset_parameters() self.lin2.reset_parameters() def forward(self, data, target_size, **kwargs): x, edge_index, batch = data.x, data.edge_index, data.batch x = F.relu(self.conv1(x, edge_index)) for conv in self.convs: x = F.relu(conv(x, edge_index)) x = global_mean_pool(x, batch, size=target_size) x = F.relu(self.lin1(x)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return F.log_softmax(x, dim=-1) def __repr__(self): return self.__class__.__name__
def __init__(self, input_dim, out_dim, filter_num, dropout=False): super(SAGE_Link, 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.linear = nn.Linear(filter_num * 2, out_dim)
class Net(torch.nn.Module): def __init__(self): super().__init__() hidden = args.hidden num_layers = 5 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 reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.conv1d.reset_parameters() self.lin1.reset_parameters() self.lin2.reset_parameters() def forward(self, data): x, edge_index, batch = data.x, data.edge_index, data.batch x = F.relu(self.conv1(x, edge_index)) for conv in self.convs: x = F.relu(conv(x, edge_index)) x = global_sort_pool(x, batch, self.k) x = x.view(len(x), self.k, -1).permute(0, 2, 1) x = F.relu(self.conv1d(x)) x = x.view(len(x), -1) x = F.relu(self.lin1(x)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return F.log_softmax(x, dim=-1)
def reset_parameters(self): for conv in self.down_convs: conv.reset_parameters() for pool in self.pools: pool.reset_parameters() for conv in self.up_convs: conv.reset_parameters()
def __init__(self, input_size, depth, rate, shapes, device): super(Net, self).__init__() self.device = device self.depth = depth self.direction = 1 self.down_list = torch.nn.ModuleList() self.up_list = torch.nn.ModuleList() self.pool_list = torch.nn.ModuleList() # encoder conv = SAGEConv(input_size, shapes[0]) self.down_list.append(conv) for i in range(self.depth - 1): pool = SAGPooling(shapes[i], rate[i]) self.pool_list.append(pool) conv = SAGEConv(shapes[i], shapes[i + 1]) self.down_list.append(conv) pool = SAGPooling(shapes[-1], rate[-1]) self.pool_list.append(pool) # decoder for i in range(self.depth - 1): conv = SAGEConv(shapes[self.depth - i - 1], shapes[self.depth - i - 2]) self.up_list.append(conv) conv = SAGEConv(shapes[0], input_size) self.up_list.append(conv)
def __init__(self, categories_nums, features_num=16, num_class=2, large_features=False, sparse=False): super(SAGE3, self).__init__() hidden = 64 embed_size = 8 dropout = 0.1 self.dropout_p = dropout self.embeddings = torch.nn.ModuleList() for max_nums in categories_nums: self.embeddings.append(Embedding(max_nums, embed_size)) # self.lin0 = Linear(embed_size*len(categories_nums)+features_num, hidden) self.conv1 = SAGEConv(embed_size * len(categories_nums) + features_num, hidden) self.conv2 = SAGEConv(hidden, hidden) self.conv3 = SAGEConv(hidden, hidden) self.lin1 = Linear(hidden, num_class)
def __init__(self): super(GCN, self).__init__() torch.manual_seed(12345) self.conv1 = SAGEConv(NUM_FEATURES, 4) self.conv2 = SAGEConv(4, 4) self.conv3 = SAGEConv(4, 2) self.classifier = Linear(2, NUM_CLASSES)
def __init__(self, hidden_channels, num_layers, max_z, train_dataset=None, use_feature=False, node_embedding=None, dropout=0.5): super(SAGE, self).__init__() self.use_feature = use_feature self.node_embedding = node_embedding self.max_z = max_z self.z_embedding = Embedding(self.max_z, hidden_channels) self.convs = ModuleList() initial_channels = hidden_channels if self.use_feature: initial_channels += train_dataset.num_features if self.node_embedding is not None: initial_channels += node_embedding.embedding_dim self.convs.append(SAGEConv(initial_channels, hidden_channels)) for _ in range(num_layers - 1): self.convs.append(SAGEConv(hidden_channels, hidden_channels)) self.dropout = dropout self.lin1 = Linear(hidden_channels, hidden_channels) self.lin2 = Linear(hidden_channels, 1)
def __init__(self, dim_node_features, dim_edge_features, dim_target, predictor_class, config): """ Initializes the model. :param dim_node_features: arbitrary object holding node feature information :param dim_edge_features: arbitrary object holding edge feature information :param dim_target: arbitrary object holding target information :param predictor_class: the class of the predictor that will classify node/graph embeddings produced by this DGN :param config: the configuration dictionary to extract further hyper-parameters """ super().__init__() num_layers = config['num_layers'] dim_embedding = config['dim_embedding'] self.aggregation = config['aggregation'] # can be mean or max if self.aggregation == 'max': self.fc_max = nn.Linear(dim_embedding, dim_embedding) self.predictor = predictor_class(dim_node_features=dim_embedding * num_layers, dim_edge_features=dim_edge_features, dim_target=dim_target, config=config) self.layers = nn.ModuleList([]) for i in range(num_layers): dim_input = dim_node_features if i == 0 else dim_embedding conv = SAGEConv(dim_input, dim_embedding) # Overwrite aggregation method (default is set to mean conv.aggr = self.aggregation self.layers.append(conv)
class GlobalAttentionNet(torch.nn.Module): 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.att = GlobalAttention(Linear(hidden, 1)) self.lin1 = Linear(hidden, hidden) self.lin2 = Linear(hidden, dataset.num_classes) def reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.att.reset_parameters() self.lin1.reset_parameters() self.lin2.reset_parameters() def forward(self, data): x, edge_index, batch = data.x, data.edge_index, data.batch x = F.relu(self.conv1(x, edge_index)) for conv in self.convs: x = F.relu(conv(x, edge_index)) x = self.att(x, batch) x = F.relu(self.lin1(x)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return F.log_softmax(x, dim=-1) def __repr__(self): return self.__class__.__name__
def __init__(self, in_feats, hidden_dim, out_feats, num_layers, dropout=0.5, normalize=False, concat=False, use_bn=False): super(GraphSAGE, self).__init__() self.convlist = nn.ModuleList() self.bn_list = nn.ModuleList() self.num_layers = num_layers self.dropout = dropout self.use_bn = use_bn if num_layers == 1: self.convlist.append( SAGEConv(in_feats, out_feats, normalize, concat)) else: self.convlist.append( SAGEConv(in_feats, hidden_dim, normalize, concat)) if use_bn: self.bn_list.append(nn.BatchNorm1d(hidden_dim)) for _ in range(num_layers - 2): self.convlist.append( SAGEConv(hidden_dim, hidden_dim, normalize, concat)) if use_bn: self.bn_list.append(nn.BatchNorm1d(hidden_dim)) self.convlist.append( SAGEConv(hidden_dim, out_feats, normalize, concat))
def __init__(self, nfeat, nhid, nclass, dropout,nlayer=2): super(GraphSAGE2, self).__init__() self.conv1 = SAGEConv(nfeat, nhid) self.conv2 = SAGEConv(nhid, nclass) self.dropout_p = dropout self.sig = nn.Sigmoid()
class GraphSAGEWithJK(torch.nn.Module): def __init__(self, dataset, num_layers, hidden): super(GraphSAGEWithJK, 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.jump = JumpingKnowledge(mode='cat') self.lin1 = Linear(num_layers * hidden, hidden) self.lin2 = Linear(hidden, dataset.num_classes) def reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.jump.reset_parameters() self.lin1.reset_parameters() self.lin2.reset_parameters() def forward(self, data): x, edge_index, batch = data.x, data.edge_index, data.batch x = F.relu(self.conv1(x, edge_index)) xs = [x] for conv in self.convs: x = F.relu(conv(x, edge_index)) xs += [x] x = self.jump(xs) x = global_mean_pool(x, batch) x = F.relu(self.lin1(x)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return F.log_softmax(x, dim=-1) def __repr__(self): return self.__class__.__name__
class GraphSAGE(torch.nn.Module): def __init__(self, num_layers=2, hidden=16, features_num=16, num_class=2): super().__init__() self.sage1 = SAGEConv(features_num, hidden) self.convs = torch.nn.ModuleList() for i in range(num_layers - 1): self.convs.append(SAGEConv(hidden, hidden)) self.lin2 = Linear(hidden, num_class) def reset_parameters(self): self.first_lin.reset_parameters() self.sage1.reset_parameters() for conv in self.convs: conv.reset_parameters() self.lin2.reset_parameters() def forward(self, data): x, edge_index, edge_weight = data.x, data.edge_index, data.edge_weight x = F.relu(self.sage1(x, edge_index, edge_weight=edge_weight)) x = F.dropout(x, p=0.5, training=self.training) for conv in self.convs: x = F.relu(conv(x, edge_index, edge_weight=edge_weight)) x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return F.log_softmax(x, dim=-1) def __repr__(self): return self.__class__.__name__
def __init__(self, hparams: dict): super().__init__() self.hparams = hparams for param_name in [ "num_node_features", "num_conv_layers", "conv_size", "lin1_size", "lin2_size", "output_size", ]: if not isinstance(hparams[param_name], int): raise Exception("Wrong hyperparameter type!") if hparams["num_conv_layers"] < 1: raise Exception("Invalid number of layers!") if hparams["activation"] == "relu": activation = nn.ReLU elif hparams["activation"] == "prelu": activation = nn.PReLU else: raise Exception("Invalid activation function name.") if hparams["pool_method"] == "add": self.pooling_method = global_add_pool elif hparams["pool_method"] == "mean": self.pooling_method = global_mean_pool elif hparams["pool_method"] == "max": self.pooling_method = global_max_pool else: raise Exception("Invalid pooling method name") self.conv_modules = nn.ModuleList() self.activ_modules = nn.ModuleList() normalize = hparams.get("normalize", False) self.conv_modules.append( SAGEConv(hparams["num_node_features"], hparams["conv_size"], normalize=normalize)) self.activ_modules.append(activation()) for _ in range(hparams["num_conv_layers"] - 1): self.conv_modules.append( SAGEConv(hparams["conv_size"], hparams["conv_size"], normalize=normalize)) self.activ_modules.append(activation()) self.lin1 = nn.Linear(hparams["conv_size"], hparams["lin1_size"]) self.activ_lin1 = activation() self.lin2 = nn.Linear(hparams["lin1_size"], hparams["lin2_size"]) self.activ_lin2 = activation() self.output = nn.Linear(hparams["lin2_size"], hparams["output_size"])
def __init__(self, config): super(Relational_GNN, self).__init__() self.num_rels = config['num_rels'] self.in_dim = config['vocab_size'] self.embed_dim = config['embed_dim'] self.dropout = config['dropout'] self.fc_dim = config['fc_dim'] self.node_drop = config['node_drop'] if config['model_name'] == 'rsage': self.conv1 = torch.nn.ModuleList([ SAGEConv(self.in_dim, self.embed_dim, normalize=True, concat=True) for _ in range(self.num_rels) ]) self.conv2 = torch.nn.ModuleList([ SAGEConv(self.embed_dim, self.embed_dim, normalize=True, concat=True) for _ in range(self.num_rels) ]) elif config['model_name'] == 'rgcn': self.conv1 = torch.nn.ModuleList([ GCNConv(self.in_dim, self.embed_dim, improved=True) for _ in range(self.num_rels) ]) self.conv2 = torch.nn.ModuleList([ GCNConv(self.embed_dim, self.embed_dim, improved=True) for _ in range(self.num_rels) ]) elif config['model_name'] == 'rgat': self.conv1 = torch.nn.ModuleList([ GATConv(self.in_dim, self.embed_dim, heads=3, concat=True, dropout=0.1) for _ in range(self.num_rels) ]) self.conv1 = torch.nn.ModuleList([ GATConv(3 * self.embed_dim, self.embed_dim, heads=3, concat=True, dropout=0.1) for _ in range(self.num_rels) ]) if config['model_name'] == 'rgat': self.classifier = nn.Sequential( nn.Dropout(config["dropout"]), nn.Linear(3 * self.embed_dim, self.fc_dim), nn.ReLU(), nn.Linear(self.fc_dim, config['n_classes'])) else: self.classifier = nn.Sequential( nn.Dropout(config["dropout"]), nn.Linear(self.embed_dim, self.fc_dim), nn.ReLU(), nn.Linear(self.fc_dim, config['n_classes']))
def __init__(self, in_channels, hidden_channels, out_channels): super(SAGE, self).__init__() self.num_layers = 2 self.convs = torch.nn.ModuleList() self.convs.append(SAGEConv(in_channels, hidden_channels)) self.convs.append(SAGEConv(hidden_channels, out_channels))
def __init__(self, args): super(GraphSAGE, self).__init__() self.feature_dim = args.feature_dim self.embedding_dim = args.embedding_dim self.SAGE_hidden_dim = args.SAGE_hidden_dim self.conv1 = SAGEConv(self.feature_dim, self.SAGE_hidden_dim) self.activate_fn = nn.ELU(inplace=True) self.conv2 = SAGEConv(self.SAGE_hidden_dim, self.embedding_dim)
def __init__(self, args): super(MetaGraphSAGE, self).__init__() self.use_cuda = args.use_cuda self.meta_num = args.meta_num self.SAGE_hidden_dim = args.SAGE_hidden_dim self.sageconv1 = nn.ModuleList([SAGEConv(args.feature_dim, self.SAGE_hidden_dim) for i in range(self.meta_num)]) self.activate_fn = nn.ELU(inplace=True) self.sageconv2 = nn.ModuleList([SAGEConv(self.SAGE_hidden_dim, args.embedding_dim) for i in range(self.meta_num)])
def __init__(self, hidden_channels): super(Net, self).__init__() in_channels = 31 out_channels = 2 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)
def __init__(self, hidden_channels: int, out_channels: int, dropout: float): super().__init__() self.dropout = dropout self.conv1 = SAGEConv((-1, -1), hidden_channels) self.conv2 = SAGEConv((-1, -1), hidden_channels) self.lin = Linear(-1, out_channels)
def __init__(self, hidden_channels): super(Net, self).__init__() in_channels = dataset.num_node_features out_channels = dataset.num_classes self.conv1 = SAGEConv(in_channels, hidden_channels, concat=True) self.conv2 = SAGEConv(hidden_channels, hidden_channels, concat=True) self.conv3 = SAGEConv(hidden_channels, hidden_channels, concat=True) self.lin = torch.nn.Linear(3 * hidden_channels, out_channels)