def __init__(self, num_vocab, max_seq_len, node_encoder, emb_dim, num_layers, hidden, ratio=0.8, dropout=0, num_class=0): super(ASAP, self).__init__() self.num_class = num_class self.max_seq_len = max_seq_len self.node_encoder = node_encoder self.conv1 = GraphConv(emb_dim, hidden, aggr='mean') self.convs = torch.nn.ModuleList() self.pools = torch.nn.ModuleList() self.convs.extend([ GraphConv(hidden, hidden, aggr='mean') for i in range(num_layers - 1) ]) self.pools.extend([ ASAPooling(hidden, ratio, dropout=dropout) for i in range((num_layers) // 2) ]) self.jump = JumpingKnowledge(mode='cat') self.lin1 = Linear(num_layers * hidden, hidden) # self.lin2 = Linear(hidden, dataset.num_classes) if self.num_class > 0: # classification self.graph_pred_linear = torch.nn.Linear(hidden, self.num_class) else: self.graph_pred_linear_list = torch.nn.ModuleList() for i in range(max_seq_len): self.graph_pred_linear_list.append(torch.nn.Linear(hidden, num_vocab))
def init_model(self, n_class, feature_num): num_layers = int(self.hyperparameters['num_layers']) hidden_size = int(2**self.hyperparameters['hidden']) lr = self.hyperparameters['lr'] if self.hyperparameters['use_linear']: self.input_lin = Linear(feature_num, hidden_size) self.convs = torch.nn.ModuleList() for i in range(num_layers): self.convs.append(GraphConv(hidden_size, hidden_size)) self.output_lin = Linear(hidden_size, n_class) else: if num_layers == 1: self.conv1 = GraphConv(in_channels=feature_num, out_channels=n_class) else: self.conv1 = GraphConv(in_channels=feature_num, out_channels=hidden_size) self.convs = torch.nn.ModuleList() for i in range(num_layers - 2): self.convs.append( GraphConv(in_channels=hidden_size, out_channels=hidden_size)) self.conv2 = GraphConv(hidden_size, n_class) self.optimizer = torch.optim.Adam(self.parameters(), lr=lr, weight_decay=5e-4) self = self.to('cuda') torch.cuda.empty_cache()
def __init__(self, num_features, n_classes, num_hidden, num_hidden_layers, dropout, activation, aggr='add', bias=True): super(PGraphConv, self).__init__() # dropout if dropout: self.dropout = nn.Dropout(p=dropout) else: self.dropout = nn.Dropout(p=0.) #activation self.activation = activation # input layer self.conv_input = GraphConv(num_features, num_hidden, aggr=aggr, bias=bias) # Hidden layers self.layers = nn.ModuleList() for _ in range(num_hidden_layers): self.layers.append( GraphConv(num_hidden, num_hidden, aggr=aggr, bias=bias)) # output layer self.conv_output = GraphConv(num_hidden, n_classes, bias=bias)
def __init__(self, input_feat_dim, node_dim1, node_dim2, dropout=0.2, adj_drop=0.2, decoder='concatDec', sigmoid=True, n_nodes=50): super().__init__() self.sigmoid = sigmoid self.adj_drop = adj_drop self.n_nodes = n_nodes self.node_dim2 = node_dim2 self.dropout_layer = torch.nn.Dropout(dropout) # encode self.conv1 = GraphConv(input_feat_dim, node_dim1) self.conv2 = GraphConv(node_dim1, node_dim2) self.fc = torch.nn.Linear(n_nodes * node_dim2, node_dim2) # decode self.fc2 = torch.nn.Linear(node_dim2, n_nodes * node_dim2) if decoder == 'bilinearDec': self.decoder = bilinearDec(node_dim2) elif decoder == 'concatDec': self.decoder = concatDec(node_dim2, node_dim1, dropout) else: raise NotImplementedError
def __init__(self, in_channels, ratio=0.5, gnn='GraphConv', min_score=None, multiplier=1, **kwargs): super(SAGPooling, self).__init__() self.in_channels = in_channels self.ratio = ratio self.min_score = min_score self.multiplier = multiplier self.gnn_name = gnn assert gnn in ['GraphConv', 'GCN', 'GAT', 'SAGE'] if gnn == 'GCN': self.gnn = GCNConv(self.in_channels, 1, **kwargs) elif gnn == 'GAT': self.gnn = GATConv(self.in_channels, 1, **kwargs) elif gnn == 'SAGE': self.gnn = SAGEConv(self.in_channels, 1, **kwargs) else: self.gnn = GraphConv(self.in_channels, 1, **kwargs) self.reset_parameters()
def __init__(self, nfeat, nhid, nclass, dropout,nlayer=2): super(StandGraph2, self).__init__() self.conv1 = GraphConv(nfeat, nhid) self.conv2 = GraphConv(nhid, nclass) self.dropout_p = dropout self.sig = nn.Sigmoid()
class GGCN(torch.nn.Module): def __init__(self, num_layers=2, hidden=200, features_num=16, num_class=2, dropout=0.5): super(GGCN, self).__init__() self.conv1 = GraphConv(features_num, hidden, aggr='add') self.lin2 = Linear(hidden, num_class) self.dropout = dropout print("hidden=%d, dropout=%f" % (hidden, self.dropout)) def reset_parameters(self): self.conv1.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.conv1(x, edge_index, edge_weight=edge_weight)) x = F.dropout(x, p=self.dropout, 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_dim, out_dim): super(RCNet, self).__init__() inter_dim = 64 self.conv1 = GraphConv(in_dim, inter_dim, 'mean') self.conv2 = GraphConv(inter_dim, out_dim)
def __init__(self, in_channels, number_hidden_layers, aggr, hidden_out_channel, out_channel, pool_layer, k=1): super(GCN_Net, self).__init__() self.in_channels = in_channels self.number_hidden_layers = number_hidden_layers #number of hidden GraphConv layers self.aggr = aggr # "add", "mean" or "max" self.pool_layer = pool_layer # 'add', 'max', 'mean' or 'sort' self.hidden_out_channel = hidden_out_channel self.out_channel = out_channel self.atom_encoder = AtomEncoder(emb_dim=self.in_channels) self.k = k self.graph_conv_list = nn.ModuleList() self.graph_conv_list.append(GraphConv(in_channels= self.in_channels, out_channels=self.hidden_out_channel, aggr=self.aggr)) self.batchnorm = BatchNorm(in_channels=self.hidden_out_channel) if self.number_hidden_layers != 0 : for i in range(self.number_hidden_layers): self.graph_conv_list.append(GraphConv(in_channels= self.hidden_out_channel, out_channels= self.hidden_out_channel, aggr=self.aggr)) self.graph_conv_list.append(GraphConv(in_channels = self.hidden_out_channel, out_channels = self.out_channel, aggr=self.aggr)) self.linear1 = nn.Linear(self.k*self.out_channel, 16) self.linear2 = nn.Linear(16, 1)
def __init__(self, input_dim, hidden_channels, target, num_layers=2): super(GNN, self).__init__() self.gconv1 = GraphConv(in_channels=672, out_channels=400, aggr='add') self.gconv2 = GraphConv(in_channels=400, out_channels=300, aggr='add') # self.gconv3 = GraphConv(in_channels=250, out_channels=64, aggr='add') # self.gconv3 = GraphConv(in_channels=(12,672), out_channels=64, aggr='add') self.conv1 = nn.Conv1d(12, 8, 5, 2) self.conv2 = nn.Conv1d(8, 4, 5, 2) self.conv3 = nn.Conv1d(4, 1, 5, 1) # self.conv4 = nn.Conv1d(1, 1, 6) self.mlp = Sequential(Linear(68, 32), ReLU(), Linear(32, 16), ReLU(), Linear(16, 1)) # MODEL CLASS ATTRIBUTES self.target = { 'valence': 0, 'arousal': 1, 'dominance': 2, 'liking': 3 }[target] self.best_val_mse = float('inf') self.best_epoch = 0 self.train_losses = [] self.eval_losses = [] self.eval_patience_count = 0 self.eval_patience_reached = False
def __init__(self, args): super(Topkpool, self).__init__() self.args = args missing_keys = list(set(["features_num", "num_class", "num_graph_features", "ratio", "dropout", "act"]) - set(self.args.keys())) if len(missing_keys) > 0: raise Exception("Missing keys: %s." % ','.join(missing_keys)) self.num_features = self.args["features_num"] self.num_classes = self.args["num_class"] self.ratio = self.args["ratio"] self.dropout = self.args["dropout"] self.num_graph_features = self.args["num_graph_features"] self.conv1 = GraphConv(self.num_features, 128) self.pool1 = TopKPooling(128, ratio=self.ratio) self.conv2 = GraphConv(128, 128) self.pool2 = TopKPooling(128, ratio=self.ratio) self.conv3 = GraphConv(128, 128) self.pool3 = TopKPooling(128, ratio=self.ratio) self.lin1 = torch.nn.Linear(256 + self.num_graph_features, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, self.num_classes)
def __init__(self, hidden_channels): super(GNN, self).__init__() torch.manual_seed(12345) self.conv1 = GraphConv(dataset.num_node_features, hidden_channels) self.conv2 = GraphConv(hidden_channels, hidden_channels) self.conv3 = GraphConv(hidden_channels, hidden_channels) self.lin = Linear(hidden_channels, dataset.num_classes)
def __init__(self, num_features, output_channels, nb_neurons=128, **kwargs): """ Parameters ---------- num_features: int number of node features output_channels: int number of classes """ super(GraphConv3TPK, self).__init__() self.conv1 = GraphConv(num_features, nb_neurons) self.pool1 = TopKPooling(nb_neurons, ratio=0.8) self.conv2 = GraphConv(nb_neurons, nb_neurons) self.pool2 = TopKPooling(nb_neurons, ratio=0.8) self.conv3 = GraphConv(nb_neurons, nb_neurons) self.pool3 = TopKPooling(nb_neurons, ratio=0.8) self.lin1 = torch.nn.Linear(nb_neurons, 64) self.lin2 = torch.nn.Linear(64, output_channels)
def __init__(self, dim_features, dim_target, config, activation=lambda x: x, withbn=True, withloop=True): super(GCN, self).__init__() self.dropout = config['dropout'] self.ingc = GraphConv(dim_features, config['embedding_dim']) self.inbn = torch.nn.BatchNorm1d(config['embedding_dim']) self.midlayer = nn.ModuleList() self.bns = nn.ModuleList() for i in range(config['num_layers']): gcb = GraphConv(config['embedding_dim'], config['embedding_dim']) self.midlayer.append(gcb) bn2 = torch.nn.BatchNorm1d(config['embedding_dim']) self.bns.append(bn2) self.classifier = SimpleClassifier(config['embedding_dim'], 64, dim_target, 0.5)
def __init__(self, num_feature, num_class): super(Net, self).__init__() self.conv1 = GraphConv(num_feature, 128) self.conv2 = GraphConv(128, 64) self.lin1 = torch.nn.Linear(64, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, num_class)
def __init__(self): super(FeatureExtractor, self).__init__() self.num_features = num_features self.nhid = nhid self.conv1 = GraphConv(self.num_features, self.nhid * 2) self.conv2 = GraphConv(self.nhid * 2, self.nhid * 2)
def __init__(self, num_layers=2, hidden=32, features_num=32, num_class=2): super(GraphGNN, self).__init__() self.first_lin = Linear(features_num, hidden) self.conv1 = GraphConv(hidden, hidden, aggr='add') self.conv2 = GraphConv(hidden, hidden, aggr='add') self.fuse_weight = torch.nn.Parameter(torch.FloatTensor(num_layers),requires_grad=True) self.fuse_weight.data.fill_(float(1) / (num_layers + 1)) self.out = Linear(hidden, num_class)
def __init__(self, num_features, num_classes=10): super(GNNNet, self).__init__() self.conv1 = GraphConv(num_features, 32) self.conv2 = GraphConv(32, 64) self.conv3 = GraphConv(64, 64) self.fc1 = torch.nn.Linear(64, 64) self.fc2 = torch.nn.Linear(64, 32) self.fc3 = torch.nn.Linear(32, num_classes)
def __init__(self, dataset, num_layers, hidden): super(Graclus, self).__init__() self.conv1 = GraphConv(dataset.num_features, hidden, aggr='mean') self.convs = torch.nn.ModuleList() for i in range(num_layers - 1): self.convs.append(GraphConv(hidden, hidden, aggr='mean')) self.lin1 = Linear(num_layers * hidden, hidden) self.lin2 = Linear(hidden, dataset.num_classes)
def __init__(self, hidden_channels): super().__init__() in_channels = dataset.num_node_features out_channels = dataset.num_classes self.conv1 = GraphConv(in_channels, hidden_channels) self.conv2 = GraphConv(hidden_channels, hidden_channels) self.conv3 = GraphConv(hidden_channels, hidden_channels) self.lin = torch.nn.Linear(3 * hidden_channels, out_channels)
def __init__(self, num_classes): super(GCNConv, self).__init__() self.conv1 = GraphConv(6, 64, aggr='add') self.conv2 = GraphConv(64 + 6, 128, aggr='add') self.conv3 = GraphConv(192 + 12, 256, aggr='add') # CAREFUL: If modifying here, check line 202 in experiments.py for pretrained model self.lin1 = torch.nn.Linear(256, num_classes)
class ASAP(torch.nn.Module): def __init__(self, num_classes, num_features, num_layers, hidden, ratio=0.8, dropout=0): super(ASAP, self).__init__() self.conv1 = GraphConv(num_features, hidden, aggr='mean') self.convs = torch.nn.ModuleList() self.pools = torch.nn.ModuleList() self.convs.extend([ GraphConv(hidden, hidden, aggr='mean') for i in range(num_layers - 1) ]) self.pools.extend([ ASAPooling(hidden, ratio, dropout=dropout) for i in range((num_layers) // 2) ]) self.jump = JumpingKnowledge(mode='cat') self.lin1 = Linear(num_layers * hidden, hidden) self.lin2 = Linear(hidden, num_classes) def reset_parameters(self): self.conv1.reset_parameters() for conv in self.convs: conv.reset_parameters() for pool in self.pools: pool.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 edge_weight = None x = F.relu(self.conv1(x, edge_index)) xs = [global_mean_pool(x, batch)] for i, conv in enumerate(self.convs): x = conv(x=x, edge_index=edge_index, edge_weight=edge_weight) x = F.relu(x) xs += [global_mean_pool(x, batch)] if i % 2 == 0 and i < len(self.convs) - 1: pool = self.pools[i // 2] x, edge_index, edge_weight, batch, _ = pool( x=x, edge_index=edge_index, edge_weight=edge_weight, batch=batch) x = self.jump(xs) 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, num_layers, num_input_features, hidden): super(GraphNN, self).__init__() self.conv1 = GraphConv(num_input_features, hidden) self.convs = torch.nn.ModuleList() for i in range(num_layers - 1): self.convs.append(GraphConv(hidden, hidden)) self.lin1 = torch.nn.Linear(3 * hidden, hidden) self.lin2 = torch.nn.Linear(hidden, 2)
def test_gcn_conv(): in_channels, out_channels = (16, 32) edge_index = torch.tensor([[0, 0, 0, 1, 2, 3], [1, 2, 3, 0, 0, 0]]) num_nodes = edge_index.max().item() + 1 x = torch.randn((num_nodes, in_channels)) conv = GraphConv(in_channels, out_channels) assert conv.__repr__() == 'GraphConv(16, 32)' assert conv(x, edge_index).size() == (num_nodes, out_channels)
def __init__(self): super(FeatureExtractor, self).__init__() self.num_features = 14 self.nhid = 128 self.conv1 = GraphConv(self.num_features, self.nhid) self.pool1 = TopKPooling(self.nhid, ratio=0.8) self.conv2 = GraphConv(self.nhid, self.nhid) self.pool2 = TopKPooling(self.nhid, ratio=0.8)
def __init__(self, in_channels, ratio=0.5): super(SAGPool, self).__init__() self.in_channels = in_channels self.ratio = ratio self.conv_1 = GraphConv(in_channels, 1) self.conv_2 = GraphConv(in_channels, 1) self.add_module('attention_layer', self.conv_1) self.add_module('attention_layer', self.conv_2)
def __init__(self, hidden_channels): super(GCN2, self).__init__() self.batchn1 = BatchNorm(dataset.num_node_features) self.conv1 = GraphConv(dataset.num_node_features, hidden_channels) self.batchn2 = BatchNorm(hidden_channels) self.conv2 = GraphConv(hidden_channels, hidden_channels) self.batchn3 = BatchNorm(hidden_channels) self.conv3 = GraphConv(hidden_channels, hidden_channels) self.batchn4 = BatchNorm(hidden_channels) self.conv4 = GraphConv(hidden_channels, hidden_channels) self.lin = Linear(hidden_channels, dataset.num_classes)
def __init__(self, dataset, num_layers, hidden): super(TopK, self).__init__() self.conv1 = GraphConv(dataset.num_features, hidden, aggr='mean') self.convs = torch.nn.ModuleList() self.pools = torch.nn.ModuleList() for i in range(num_layers - 1): self.convs.append(GraphConv(hidden, hidden, aggr='mean')) self.pools.append(TopKPooling(hidden, ratio=0.8)) self.jump = JumpingKnowledge(mode='cat') self.lin1 = Linear(num_layers * hidden, hidden) self.lin2 = Linear(hidden, dataset.num_classes)
def __init__(self, num_layers=2, hidden=200, features_num=16, num_class=2, dropout=0.5): super(GGCN, self).__init__() self.conv1 = GraphConv(features_num, hidden, aggr='add') self.lin2 = Linear(hidden, num_class) self.dropout = dropout print("hidden=%d, dropout=%f" % (hidden, self.dropout))
def __init__(self, in_channels, node_score_method=None, dropout=0): super(StarPooling, self).__init__() self.in_channels = in_channels if node_score_method is None: node_score_method = self.compute_node_score_tanh self.compute_node_score = node_score_method self.dropout = dropout self.score_func = GraphConv(in_channels, 1) self.reset_parameters()