def test_gated_graph_conv(): x = torch.randn(4, 16) edge_index = torch.tensor([[0, 0, 0, 1, 2, 3], [1, 2, 3, 0, 0, 0]]) row, col = edge_index value = torch.rand(row.size(0)) adj2 = SparseTensor(row=row, col=col, value=value, sparse_sizes=(4, 4)) adj1 = adj2.set_value(None) conv = GatedGraphConv(32, num_layers=3) assert conv.__repr__() == 'GatedGraphConv(32, num_layers=3)' out1 = conv(x, edge_index) assert out1.size() == (4, 32) assert torch.allclose(conv(x, adj1.t()), out1, atol=1e-6) out2 = conv(x, edge_index, value) assert out2.size() == (4, 32) assert torch.allclose(conv(x, adj2.t()), out2, atol=1e-6) t = '(Tensor, Tensor, OptTensor) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert jit(x, edge_index).tolist() == out1.tolist() assert jit(x, edge_index, value).tolist() == out2.tolist() t = '(Tensor, SparseTensor, OptTensor) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert torch.allclose(jit(x, adj1.t()), out1, atol=1e-6) assert torch.allclose(jit(x, adj2.t()), out2, atol=1e-6)
def __init__(self, in_feats, hid_feats, out_feats): super(BUrumorGGCN, self).__init__() self.conv1 = GatedGraphConv(in_feats, hid_feats, aggr='add', bias=True) self.conv2 = GatedGraphConv(hid_feats + in_feats, out_feats, aggr='add', bias=True)
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 = GatedGraphConv(out_channels, num_layers=3) assert conv.__repr__() == 'GatedGraphConv(32, num_layers=3)' assert conv(x, edge_index).size() == (num_nodes, out_channels)
def __init__(self, features_num=16, num_class=2, dropout=0.2, num_layers=2, hidden=16): super(GGC, self).__init__() self.conv1 = GatedGraphConv(features_num, hidden) self.conv2 = GatedGraphConv(hidden, num_class) self.dropout = dropout
def __init__(self, embeddings, word_vec_size, gnn_type, gnn_layers, rnn_size): super(GraphEncoder, self).__init__() self.is_graph_encoder = True self.gnn_type = gnn_type self.gnn_layers = gnn_layers self.embeddings = embeddings self.dropout = nn.Dropout(0.3) self.num_inputs = word_vec_size self.rnn_size = rnn_size if self.gnn_type == 'ggnn': self.gnn_td = GatedGraphConv(self.num_inputs, self.gnn_layers) self.gnn_bu = GatedGraphConv(self.num_inputs, self.gnn_layers) elif self.gnn_type == 'gat': self.gnn_td = GATConv(self.num_inputs, self.num_inputs, heads=self.gnn_layers, concat=False, dropout=0.3) self.gnn_bu = GATConv(self.num_inputs, self.num_inputs, heads=self.gnn_layers, concat=False, dropout=0.3) else: self.gins_td = [] self.gins_bu = [] num_layers = self.gnn_layers nn_td = Sequential(Linear(self.num_inputs, self.num_inputs), ReLU(), Linear(self.num_inputs, self.num_inputs)) nn_tb = Sequential(Linear(self.num_inputs, self.num_inputs), ReLU(), Linear(self.num_inputs, self.num_inputs)) for x in range(num_layers): gin = GINConv(nn_td) self.gins_td.append(gin.cuda()) gin = GINConv(nn_tb) self.gins_bu.append(gin.cuda()) self.bilstm = nn.LSTM(self.rnn_size, self.rnn_size // 2, num_layers=2, bidirectional=True, dropout=0.3) if self.gnn_type == 'gin': self.layers_seq = nn.Sequential(*self.gins_td, *self.gins_bu, self.bilstm)
def __init__(self, device: torch.device, *, embedding_dim: int = 64, no_shortcut: bool = False, **kwargs ): super().__init__(device) self.embedding_dim = embedding_dim self.no_shortcut = no_shortcut # self.aggregator_type = aggregator_type self.embed = GatedGraphConv(embedding_dim, 2, aggr='mean') self.conv2= GatedGraphConv(embedding_dim, 2, aggr='mean') self.fc = nn.Linear(embedding_dim, 2) self.activate = nn.ELU()
def __init__(self, net_params): super().__init__() in_dim_node = net_params['in_dim'] # node_dim (feat is an integer) in_dim_edge = 1 # edge_dim (feat is a float) hidden_dim = net_params['hidden_dim'] n_classes = net_params['n_classes'] self.dropout = net_params['dropout'] n_layers = net_params['L'] self.readout = net_params['readout'] self.batch_norm = net_params['batch_norm'] self.residual = net_params['residual'] self.n_classes = n_classes self.device = net_params['device'] 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) self.embedding_h = nn.Linear(in_dim_node, hidden_dim) # node feat is an integer # self.embedding_e = nn.Linear(in_dim_edge, hidden_dim) # edge feat is a float self.layers = nn.ModuleList( [GatedGraphConv(hidden_dim, n_layers, aggr='add')]) # self.layers = nn.ModuleList([GatedGCNLayer(hidden_dim, hidden_dim, dropout, # self.batch_norm, self.residual) for _ in range(n_layers)]) if self.batch_norm: self.normlayers = nn.ModuleList([nn.BatchNorm1d(hidden_dim)]) # self.MLP_layer = MLPReadout(hidden_dim, n_classes) self.MLP_layer = nn.Linear(hidden_dim, n_classes, bias=True)
def __init__(self, hidden_size, opt, n_node, step=1): super(GNN, self).__init__() self.step = step self.hidden_size = hidden_size self.input_size = hidden_size * 2 self.gate_size = 3 * hidden_size self.w_ih = Parameter(torch.Tensor(self.gate_size, self.input_size)) self.w_hh = Parameter(torch.Tensor(self.gate_size, self.hidden_size)) self.b_ih = Parameter(torch.Tensor(self.gate_size)) self.b_hh = Parameter(torch.Tensor(self.gate_size)) self.b_iah = Parameter(torch.Tensor(self.hidden_size)) self.b_oah = Parameter(torch.Tensor(self.hidden_size)) self.linear_edge_in = nn.Linear(self.hidden_size, self.hidden_size, bias=True) self.linear_edge_out = nn.Linear(self.hidden_size, self.hidden_size, bias=True) self.linear_edge_f = nn.Linear(self.hidden_size, self.hidden_size, bias=True) heads = 1 self.conv1 = GATConv(self.hidden_size, self.hidden_size, heads=heads, dropout=0.6) # On the Pubmed dataset, use heads=8 in conv2. self.conv2 = GATConv(heads * self.hidden_size, self.hidden_size, heads=1, concat=False, dropout=0.6) self.ggnn = GatedGraphConv(self.hidden_size, step + 1)
def __init__(self, input_size, hidden_size, output_size, seq_len, edge_embedding_dim, sampling, recurrent): super(Decoder, self).__init__() self.input_size = input_size self.hidden_size = hidden_size self.output_size = output_size self.seq_len = seq_len self.edge_embedding_dim = edge_embedding_dim self.sampling = sampling self.recurrent = recurrent self.node_transform = Sequential( Linear(self.input_size, self.output_size), ReLU()) if self.recurrent == True: self.rnn_graph_conv = GatedGraphConv(out_channels=self.input_size, num_layers=self.num_layers) else: self.MLP = Sequential( Linear(self.edge_embedding_dim, self.hidden_size), ReLU(), Linear(self.hidden_size, 2 * self.input_size * self.input_size)) self.graph_conv_1 = MLPGraphConv(in_channels=self.input_size, out_channels=self.input_size, nn=self.MLP, root_weight=True, bias=True, aggr='add') self.graph_conv_2 = MLPGraphConv(in_channels=self.input_size, out_channels=self.input_size, nn=self.MLP, root_weight=True, bias=True, aggr='add') self.graph_conv_list = ModuleList( [self.graph_conv_1, self.graph_conv_2])
def get_layer(self, in_dim, out_dim): if self is GNN_TYPE.GCN: return GCNConv(in_channels=in_dim, out_channels=out_dim) elif self is GNN_TYPE.GGNN: return GatedGraphConv(out_channels=out_dim, num_layers=1) elif self is GNN_TYPE.GIN: return GINConv( nn.Sequential(nn.Linear(in_dim, out_dim), nn.BatchNorm1d(out_dim), nn.ReLU(), nn.Linear(out_dim, out_dim), nn.BatchNorm1d(out_dim), nn.ReLU())) elif self is GNN_TYPE.GAT: # 4-heads, although the paper by Velickovic et al. had used 6-8 heads. # The output will be the concatenation of the heads, yielding a vector of size out_dim num_heads = 4 return GATConv(in_dim, out_dim // num_heads, heads=num_heads) elif self is GNN_TYPE.GAT2: # 4-heads, although the paper by Velickovic et al. had used 6-8 heads. # The output will be the concatenation of the heads, yielding a vector of size out_dim num_heads = 4 return GAT2Conv(in_dim, out_dim // num_heads, heads=num_heads) elif self is GNN_TYPE.LUONG_GAT: # 4-heads, although the paper by Velickovic et al. had used 6-8 heads. # The output will be the concatenation of the heads, yielding a vector of size out_dim num_heads = 4 return LuongGATConv(in_dim, out_dim // num_heads, heads=num_heads) elif self is GNN_TYPE.DP_GAT: # 4-heads, although the paper by Velickovic et al. had used 6-8 heads. # The output will be the concatenation of the heads, yielding a vector of size out_dim num_heads = 4 return DotProductGATConv(in_dim, out_dim // num_heads, heads=num_heads)
def __init__(self, num_vocab, max_seq_len, node_encoder, emb_dim, layer_timesteps=[5], num_class=0): super(GGNN_Simple, self).__init__() self.num_class = num_class # if we do classification self.layer_timesteps = layer_timesteps # self.residual_connections = residual_connections # 'use_edge_bias': False, self.emb_dim = emb_dim self.num_vocab = num_vocab self.max_seq_len = max_seq_len self.node_encoder = node_encoder self.convs = [] for layer_idx, t in enumerate(layer_timesteps): self.convs += [GatedGraphConv(emb_dim, t)] self.convs = nn.ModuleList(self.convs) self.classifier_l = nn.Sequential( nn.Linear(2*emb_dim, emb_dim), nn.Sigmoid() ) self.classifier_r = nn.Sequential( nn.Linear(2*emb_dim, emb_dim), nn.Tanh() ) if self.num_class > 0: self.graph_pred_linear = torch.nn.Linear(emb_dim, 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(emb_dim, self.num_vocab))
def __init__(self, embed_size, vocab_size, keyword_vocab_size, hidden_size, output_size, n_layers, gnn, aggregation, n_heads=0, dropout=0, bidirectional=False, \ utterance_encoder="", keywordid2wordid=None, keyword_mask_matrix=None, nodeid2wordid=None, keywordid2nodeid=None, concept_encoder="mean", \ combine_node_emb="mean"): super(KW_GNN, self).__init__() self.embed_size = embed_size self.vocab_size = vocab_size self.keyword_vocab_size = keyword_vocab_size self.hidden_size = hidden_size self.output_size = output_size self.n_layers = n_layers self.gnn = gnn self.aggregation = aggregation self.n_heads = n_heads self.dropout = dropout self.bidirectional = bidirectional self.utterance_encoder_name = utterance_encoder self.keywordid2wordid = keywordid2wordid self.keyword_mask_matrix = keyword_mask_matrix self.nodeid2wordid = nodeid2wordid self.keywordid2nodeid = keywordid2nodeid self.concept_encoder = concept_encoder self.combine_node_emb = combine_node_emb self.num_nodes = nodeid2wordid.shape[0] self.embedding = nn.Embedding(vocab_size, embed_size) # GNN learning if gnn == "GatedGraphConv": self.conv1 = GatedGraphConv(hidden_size, num_layers=n_layers) output_size = hidden_size if n_layers == 1: output_size = hidden_size # aggregation if aggregation in ["mean", "max"]: output_size = output_size # utterance encoder if self.utterance_encoder_name == "HierGRU": self.utterance_encoder = nn.GRU(embed_size, hidden_size, 1, batch_first=True, dropout=dropout, bidirectional=bidirectional) self.context_encoder = nn.GRU( 2 * hidden_size if bidirectional else hidden_size, hidden_size, 1, batch_first=True, dropout=dropout, bidirectional=bidirectional) output_size = output_size + 2 * hidden_size if bidirectional else output_size + hidden_size # final linear layer self.mlp = nn.Linear(output_size, keyword_vocab_size)
def __init__(self, hidden_size, n_node): super(GNNModel, self).__init__() self.hidden_size, self.n_node = hidden_size, n_node self.embedding = nn.Embedding(self.n_node, self.hidden_size) self.gated = GatedGraphConv(self.hidden_size, num_layers=1) self.e2s = Embedding2Score(self.hidden_size) self.loss_function = nn.CrossEntropyLoss() self.reset_parameters()
def _create_layers(self): self.conv_layer = GatedGraphConv(out_channels=self.conv_out_channels, num_layers=self.conv_num_layers, aggr=self.conv_aggr, bias=True) self.recurrent_layer = LSTM(input_size=self.conv_out_channels, hidden_size=self.lstm_out_channels, num_layers=self.lstm_num_layers)
def __init__(self, node_size): super(GatedGCN, self).__init__() self.node_per_graph = node_size self.linprev = EdgeConv(MLP([4*2, 64, 64, 64]), aggr = 'max') self.conv1 = GatedGraphConv(256, 2) self.bn1 = torch.nn.BatchNorm1d(256) self.conv2 = GatedGraphConv(256, 2) self.bn2 = torch.nn.BatchNorm1d(256) self.conv3 = GatedGraphConv(256, 2) self.bn3 = torch.nn.BatchNorm1d(256) self.conv4 = GatedGraphConv(256, 3) self.bn4 = torch.nn.BatchNorm1d(256) self.mlp = Seq( MLP([256*2*4, 512]), Dropout(0.4), MLP([512, 128]), Dropout(0.4), Lin(128, 40))
def test_gated_graph_conv(): in_channels, out_channels = (16, 32) edge_index = torch.tensor([[0, 0, 0, 1, 2, 3], [1, 2, 3, 0, 0, 0]]) edge_weight = torch.randn(edge_index.size(1)) num_nodes = edge_index.max().item() + 1 x = torch.randn((num_nodes, in_channels)) conv = GatedGraphConv(out_channels, num_layers=3) assert conv.__repr__() == 'GatedGraphConv(32, num_layers=3)' out1 = conv(x, edge_index) assert out1.size() == (num_nodes, out_channels) out2 = conv(x, edge_index, edge_weight) assert out2.size() == (num_nodes, out_channels) jit_conv = conv.jittable(x=x, edge_index=edge_index) jit_conv = torch.jit.script(jit_conv) assert jit_conv(x, edge_index).tolist() == out1.tolist() assert jit_conv(x, edge_index, edge_weight).tolist() == out2.tolist()
def __init__(self, vocablen, embedding_dim, num_layers, device): super(GGNN, self).__init__() self.device = device #self.num_layers=num_layers self.embed = nn.Embedding(vocablen, embedding_dim) self.edge_embed = nn.Embedding(20, embedding_dim) #self.gmn=nn.ModuleList([GMNlayer(embedding_dim,embedding_dim) for i in range(num_layers)]) self.ggnnlayer = GatedGraphConv(embedding_dim, num_layers) self.mlp_gate = nn.Sequential(nn.Linear(embedding_dim, 1), nn.Sigmoid()) self.pool = GlobalAttention(gate_nn=self.mlp_gate)
def gnn_map(gnn_name, in_dim, out_dim, concat=False, bias=True) -> nn.Module: """ :param gnn_name: :param in_dim: :param out_dim: :param concat: for gat, concat multi-head output or not :return: GNN model """ if gnn_name == "gat_8": return GATConv(in_dim, out_dim, 8, concat=concat, bias=bias) elif gnn_name == "gat_6": return GATConv(in_dim, out_dim, 6, concat=concat, bias=bias) elif gnn_name == "gat_4": return GATConv(in_dim, out_dim, 4, concat=concat, bias=bias) elif gnn_name == "gat_2": return GATConv(in_dim, out_dim, 2, concat=concat, bias=bias) elif gnn_name in ["gat_1", "gat"]: return GATConv(in_dim, out_dim, 1, concat=concat, bias=bias) elif gnn_name == "gcn": return GCNConv(in_dim, out_dim) elif gnn_name == "cheb": return ChebConv(in_dim, out_dim, K=2, bias=bias) elif gnn_name == "sage": return SAGEConv(in_dim, out_dim, bias=bias) elif gnn_name == "gated": return GatedGraphConv(in_dim, out_dim, bias=bias) elif gnn_name == "arma": return ARMAConv(in_dim, out_dim, bias=bias) elif gnn_name == "sg": return SGConv(in_dim, out_dim, bias=bias) elif gnn_name == "linear": return LinearConv(in_dim, out_dim, bias=bias) elif gnn_name == "zero": return ZeroConv() elif gnn_name == "identity": return Identity() elif hasattr(torch_geometric.nn, gnn_name): cls = getattr(torch_geometric.nn, gnn_name) assert isinstance(cls, type), "Only support modules, get %s" % (gnn_name) kwargs = { "in_channels": in_dim, "out_channels": out_dim, "concat": concat, "bias": bias, } kwargs = { key: kwargs[key] for key in cls.__init__.__code__.co_varnames if key in kwargs } return cls(**kwargs) raise KeyError("Cannot parse key %s" % (gnn_name))
def __init__(self, args, trained=True, bn=False, backbone_type='res101'): super(Vrd_Graph_GA_v4, self).__init__() self.n_obj = args.num_classes self.n_rel = args.num_relations global res101 if trained and backbone_type == 'res101': res101 = resnet.__dict__['resnet101'](pretrained=False, norm_layer=FrozenBatchNorm2d) weight_path = "../models/resnet101-5d3b4d8f.pth" state = torch.load(weight_path) res101.load_state_dict(state) layers_res = OrderedDict() for k, v in res101.named_children(): if k in ['conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3']: layers_res[k] = v backbone = nn.Sequential(layers_res) # 2048 self.features = backbone else: res101 = resnet.__dict__['resnet101'](pretrained=False, norm_layer=FrozenBatchNorm2d) layers_res = OrderedDict() for k, v in res101.named_children(): if k in ['conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3']: layers_res[k] = v backbone = nn.Sequential(layers_res) # 2048 self.features = backbone network.set_trainable(self.features, requires_grad=False) self.roi_pool = RoIPool((14, 14), 1.0 / 16) self.inter_layer = res101.layer4 network.set_trainable(self.inter_layer, requires_grad=False) self.pool = nn.AdaptiveAvgPool2d(output_size=(1, 1)) self.fc6 = nn.Linear(2048, 256) self.fc_obj = nn.Linear(2048, self.n_obj) self.gat_conv_rel1 = GatedGraphConv(out_channels=256, num_layers=2) self.rel_1 = nn.Linear(768, 256) self.rel_2 = nn.Linear(256, self.n_rel) self.fc_lov = nn.Linear(8, 256) self.fc_sub_obj = nn.Linear(2 * 300, 256) self.initialize_param()
def __init__(self, embeddings, edge_embeddings, num_inputs, num_units, num_layers=1, geometric_layer="rgcn"): super(DualGraphEncoder, self).__init__() self.embeddings = embeddings self.edge_embeddings = edge_embeddings self.tanh = nn.Tanh() self.dropout = nn.Dropout(0.3) # The number of expected features in the input x self.num_layers = num_layers self.num_inputs = num_inputs # The number of features in the hidden state h self.num_units = num_units self.geometric_layer = geometric_layer self.gated_gcn_in = GatedGraphConv(num_inputs, 5) self.gated_gcn_out = GatedGraphConv(num_inputs, 5) self.gated_gat_in = GATConv(num_inputs, num_units, heads=3, concat=False, dropout=0.3) #self.gated_gat_out = GATConv(num_inputs, num_units, heads=3, concat=False, dropout=0.3) hidden_size = self.num_units * 3 // 2 self.bilstm = nn.LSTM(self.num_inputs * 3, hidden_size, num_layers=2, bidirectional=True, dropout=0.3)
def __init__(self, config): super(Net, self).__init__() annotation_size = config["hidden_size_orig"] hidden_size = config["gnn_h_size"] n_steps = config["num_timesteps"] num_cls = 2 self.reduce = nn.Linear(annotation_size, hidden_size) self.conv = GatedGraphConv(hidden_size, n_steps) self.agg = GlobalAttention(nn.Linear(hidden_size, 1), nn.Linear(hidden_size, 2)) self.lin = nn.Linear(hidden_size, num_cls)
def __init__( self, feat_size=19, gather_width=64, k=2, neighbor_threshold=None, output_pool_result=False, bn_track_running_stats=False, ): super(PotentialNetPropagation, self).__init__() assert neighbor_threshold is not None self.neighbor_threshold = neighbor_threshold self.bn_track_running_stats = bn_track_running_stats self.edge_attr_size = 1 self.k = k self.gather_width = gather_width self.feat_size = feat_size self.edge_network_nn = nn.Sequential( nn.Linear(self.edge_attr_size, int(self.feat_size / 2)), nn.Softsign(), nn.Linear(int(self.feat_size / 2), self.feat_size), nn.Softsign(), ) self.edge_network = NNConv( self.feat_size, self.edge_attr_size * self.feat_size, nn=self.edge_network_nn, root_weight=True, aggr="add", ) self.gate = GatedGraphConv(self.feat_size, self.k, edge_network=self.edge_network) self.attention = PotentialNetAttention( net_i=nn.Sequential( nn.Linear(self.feat_size * 2, self.feat_size), nn.Softsign(), nn.Linear(self.feat_size, self.gather_width), nn.Softsign(), ), net_j=nn.Sequential(nn.Linear(self.feat_size, self.gather_width), nn.Softsign()), ) self.output_pool_result = output_pool_result if self.output_pool_result: self.global_add_pool = global_add_pool
def __init__(self, config: DictConfig, vocab: Vocabulary, vocabulary_size: int, pad_idx: int): super(GatedGraphConvEncoder, self).__init__() self.__config = config self.__pad_idx = pad_idx self.__st_embedding = STEncoder(config, vocab, vocabulary_size, pad_idx) self.input_GCL = GatedGraphConv(out_channels=config.hidden_size, num_layers=config.n_gru) self.input_GPL = TopKPooling(config.hidden_size, ratio=config.pooling_ratio) for i in range(config.n_hidden_layers - 1): setattr( self, f"hidden_GCL{i}", GatedGraphConv(out_channels=config.hidden_size, num_layers=config.n_gru)) setattr( self, f"hidden_GPL{i}", TopKPooling(config.hidden_size, ratio=config.pooling_ratio)) self.attpool = GlobalAttention(torch.nn.Linear(config.hidden_size, 1))
def __init__( self, embed_dim: int, num_layers: int, heads: int = 8, normalization: str = "batch", feed_forward_hidden: int = 512, pooling_method: str = "add", ) -> None: super().__init__() self.embed_dim = embed_dim self.num_layers = num_layers self.heads = heads assert (self.embed_dim % self.heads) == 0 self.pooling_func = get_pooling_func(pooling_method) self.norm_class = get_normalization_class(normalization) self.norm_out = GraphNorm(self.embed_dim) self.gnn_layer = GatedGraphConv(out_channels=self.embed_dim, num_layers=1) self.reversed_gnn_layer = GatedGraphConv(out_channels=self.embed_dim, num_layers=1) self.edge_extractor = EdgeFeatureExtractor(in_channels=self.embed_dim, edge_dim=self.embed_dim)
def __init__(self, hidden_size, n_node): super(testGNN, self).__init__() self.hidden_size, self.n_node = hidden_size, n_node self.embedding = torch.nn.Embedding(self.n_node, self.hidden_size) self.gcn = GCNConv(self.hidden_size, self.hidden_size) self.gcn2 = GCNConv(self.hidden_size, self.hidden_size) self.ggcn = GatedGraphConv(self.hidden_size, self.hidden_size) self.gat1 = GATConv(self.hidden_size, self.hidden_size, heads=8, negative_slope=0.2) self.gat2 = GATConv(8 * self.hidden_size, self.hidden_size, heads=1, negative_slope=0.2) self.e2s = Embedding2Score(self.hidden_size)
def __init__(self, embed_size, vocab_size, gnn_hidden_size, gnn_layers, encoder_hidden_size, encoder_layers, n_heads, gnn, encoder, matching, \ aggregation, use_keywords, keyword_encoder, keyword_score_weight=1, dropout=0, CN_hopk_edge_matrix_mask=None, nodeid2wordid=None, \ keywordid2wordid=None, keywordid2nodeid=None, concept_encoder="mean", combine_word_concepts="concat"): super(CoGraphMatcher, self).__init__() self.embed_size = embed_size self.vocab_size = vocab_size self.gnn_hidden_size = gnn_hidden_size self.encoder_hidden_size = encoder_hidden_size self.gnn_layers = gnn_layers self.encoder_layers = encoder_layers self.n_heads = n_heads self.gnn = gnn self.encoder = encoder self.aggregation = aggregation self.use_keywords = use_keywords self.keyword_score_weight = keyword_score_weight self.keyword_encoder = keyword_encoder self.dropout = dropout self.CN_hopk_edge_matrix_mask = CN_hopk_edge_matrix_mask self.nodeid2wordid = nodeid2wordid self.keywordid2wordid = keywordid2wordid self.keywordid2nodeid = keywordid2nodeid self.concept_encoder = concept_encoder self.combine_word_concepts = combine_word_concepts self.num_nodes = nodeid2wordid.shape[0] self.embedding = nn.Embedding(vocab_size, embed_size) # GNN learning encoder_input_size = gnn_hidden_size if gnn == "GatedGraphConv": self.conv1 = GatedGraphConv(gnn_hidden_size, num_layers=gnn_layers) if self.encoder == "GRU": self.utterance_encoder = nn.GRU(encoder_input_size, encoder_hidden_size, encoder_layers, batch_first=True, dropout=dropout, bidirectional=True) self.candidate_encoder = nn.GRU(encoder_input_size, encoder_hidden_size, encoder_layers, batch_first=True, dropout=dropout, bidirectional=True)
def __init__(self, hidden_size, n_node): super(GNNModel, self).__init__() self.hidden_size, self.n_node = hidden_size, n_node self.embedding = nn.Embedding(self.n_node, self.hidden_size) self.gat1 = GATConv(self.hidden_size, self.hidden_size, heads=8, negative_slope=0.2) self.gat2 = GATConv(8 * self.hidden_size, self.hidden_size, heads=1, negative_slope=0.2) self.sage1 = SAGEConv(self.hidden_size, self.hidden_size) self.sage2 = SAGEConv(self.hidden_size, self.hidden_size) self.gated = GatedGraphConv(self.hidden_size, num_layers=2) self.e2s = Embedding2Score(self.hidden_size) self.loss_function = nn.CrossEntropyLoss() self.reset_parameters()
def __init__(self, node_dim: int, num_convs: int, num_layers: Union[int, List[int]], num_edge_types: int): super().__init__() self.convs = [] if isinstance(num_layers, int): num_layers = [num_layers] * num_convs for i in range(num_convs): self.convs.append(GatedGraphConv(node_dim, num_layers=1)) # Weight given to each edge type self.edge_type_weights = torch.nn.Parameter( torch.FloatTensor((1.0, ) * num_edge_types)) # Simple linear layer for the output of conv3 self.lin1 = torch.nn.Linear(node_dim, node_dim) # Slope for leaky relus self.neg_slope = 0.01
def init_model(self, n_class, feature_num): num_layers = self.hyperparameters['num_layers'] hidden_size = int(2**self.hyperparameters['hidden']) lr = self.hyperparameters['lr'] gated_conv_layers = int(self.hyperparameters['gated_conv_layers']) self.input_linear = Linear(feature_num, hidden_size) self.convs = torch.nn.ModuleList() for i in range(num_layers - 1): self.convs.append( GatedGraphConv(out_channels=hidden_size, num_layers=gated_conv_layers)) self.output_linear = Linear(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, poi_size, embedding_matrix, struct_topology, user_history_data_dict): super(Net, self).__init__() self.verbose = True self.use_cuda = True self.embedding_dim = Parameters.type_embedding_dim self.embedding_matrix = embedding_matrix self.struct_topology = struct_topology self.hidden_dim = Parameters.HIDDEN_SIZE self.linear_size = 30 self.batch_size = 4 self.poi_size = poi_size self.drop_out = Parameters.DROPOUT_RATE self.num_classes = 5 self.n_epochs = 3 self.poi_size = embedding_matrix.shape[0] self.user_history_data_dict = user_history_data_dict self.conv3 = GatedGraphConv(self.hidden_dim, 3) # self.conv4 = ChebConv(self.hidden_dim, 56, 2) # self.conv5 = ChebConv(16, self.num_classes, 2) self.fc1 = nn.Sequential( nn.BatchNorm1d(self.hidden_dim * 2), nn.Linear(self.hidden_dim * 2, self.linear_size), nn.ReLU(), nn.BatchNorm1d(self.linear_size), nn.Dropout(self.drop_out) ) self.fc2 = nn.Sequential( nn.BatchNorm1d(self.hidden_dim * 2), nn.Linear(self.hidden_dim * 2, self.linear_size), nn.ReLU(), nn.BatchNorm1d(self.linear_size), nn.Dropout(self.drop_out), nn.Linear(self.linear_size, self.num_classes) ) self.embed = nn.Embedding(self.poi_size, self.embedding_dim, padding_idx=0) self.embed.weight.data.copy_(torch.from_numpy(embedding_matrix)) self.bat_nor_embed = nn.BatchNorm1d(self.embedding_dim) self.lstm = nn.LSTM(self.hidden_dim, self.hidden_dim, batch_first=True)