def __init__(self, args): super(Model_joint, self).__init__() self.args = args self.num_features = args.num_features self.nhid = args.nhid self.num_classes = args.num_classes self.pooling_ratio = args.pooling_ratio self.dropout_ratio = args.dropout_ratio self.sample = args.sample_neighbor self.sparse = args.sparse_attention self.sl = args.structure_learning self.lamb = args.lamb self.conv1 = GCNConv(self.num_features, self.nhid) self.conv2 = GCN(self.nhid, self.nhid) self.conv3 = GCN(self.nhid, self.nhid) self.pool1 = HGPSLPool(self.nhid, self.pooling_ratio, self.sample, self.sparse, self.sl, self.lamb) self.pool2 = HGPSLPool(self.nhid, self.pooling_ratio, self.sample, self.sparse, self.sl, self.lamb) self.lin1 = torch.nn.Linear(self.nhid * 2, self.nhid) self.lin2 = torch.nn.Linear(self.nhid, self.nhid) self.lin3 = torch.nn.Linear(self.nhid * 2, self.nhid) self.lin4 = torch.nn.Linear(self.nhid, self.nhid) self.lin5 = torch.nn.Linear(self.nhid , self.num_classes)
def __init__(self, n_in, n_h, activation): super(GMI, self).__init__() self.gcn1 = GCN( n_in, n_h, activation ) # if on citeseer and pubmed, the encoder is 1-layer GCN, you need to modify it self.gcn2 = GCN(n_h, n_h, activation) self.disc1 = Discriminator(n_in, n_h) self.disc2 = Discriminator(n_h, n_h) self.avg_neighbor = AvgNeighbor() self.prelu = nn.PReLU() self.sigm = nn.Sigmoid()
def __init__(self, ft_size, hid_units, n_networks, same_discriminator=True): super(modeler, self).__init__() self.gcn_list = nn.ModuleList( [GCN(ft_size, hid_units) for _ in range(n_networks)]) self.w_list = nn.ModuleList([ nn.Linear(hid_units, hid_units, bias=False) for _ in range(n_networks) ]) self.y_list = nn.ModuleList( [nn.Linear(hid_units, 1) for _ in range(n_networks)]) self.disc_layers = InterDiscriminator(hid_units, ft_size) if same_discriminator: self.disc_fusion = self.disc_layers else: self.disc_fusion = InterDiscriminator(hid_units, ft_size) self.att_act1 = nn.Tanh() self.att_act2 = nn.Softmax(dim=-1) for m in self.modules(): self.weights_init(m)
def __init__(self, n_in, n_h, activation): super(DGI, self).__init__() self.gcn = GCN(n_in, n_h, activation) self.read = AvgReadout() self.sigm = nn.Sigmoid() self.disc = Discriminator(n_h) self.disc2 = Discriminator2(n_h)
def get_chordal_one_model(n_nodes, n_features, num_classes): """ Returns a model specifically tailored to classify the chordal one dataset. :param n_nodes: number of nodes :param n_features: number of features :param num_classes: number of target classes :return: tf model """ node_features_input_layer = layers.Input(shape=(n_nodes, n_features), name='node_feature_input') adjacency_matrix_input_layer = layers.Input(shape=(n_nodes, n_nodes), name='adjacency_matrix_input') x = GCN(16, "relu")([node_features_input_layer, adjacency_matrix_input_layer]) # x = layers.Dropout(rate=0.3)(x) # sum-pooling and dense connection to output nodes x = SumPool(16)(x) x = layers.Dense(num_classes, activation="softmax", activity_regularizer=tf.keras.regularizers.l1_l2(0.1))(x) model = tf.keras.Model( inputs=[node_features_input_layer, adjacency_matrix_input_layer], outputs=[x]) return model
def __init__(self, args): super(modeler, self).__init__() self.args = args self.gcn = GCN(args.ft_size, args.hid_units, args.activation, args.drop_prob, args.isBias) # one discriminator self.disc = Discriminator(args.hid_units) self.readout_func = self.args.readout_func
def __init__(self, args): super(Encoder, self).__init__() self.args = args self.num_features = args.num_features self.nhid = args.hdim self.num_classes = args.num_classes self.pooling_ratio = args.pooling_ratio self.dropout_ratio = args.dropout_ratio self.sample = args.sample_neighbor self.sparse = args.sparse_attention self.sl = args.structure_learning self.lamb = args.lamb self.conv1 = GCNConv(self.num_features, self.nhid) self.conv2 = GCN(self.nhid, self.nhid) self.conv3 = GCN(self.nhid, self.nhid) self.pool1 = HGPSLPool(self.nhid, self.pooling_ratio, self.sample, self.sparse, self.sl, self.lamb) self.pool2 = HGPSLPool(self.nhid, self.pooling_ratio, self.sample, self.sparse, self.sl, self.lamb)
def __init__(self, n_in, n_h, activation, k, device, hard, batch_size): super(DGI, self).__init__() self.gcn = GCN(n_in, n_h, activation) self.assign = Assign(k, n_h, device, hard) self.sigm = nn.Sigmoid() self.disc = Discriminator(n_h) self.k = k
def __init__(self, nfeat, nhid, shid, P, act): """Dense version of GAT.""" super(HGCN, self).__init__() self.gcn_level_embeddings = [] self.P = P #number of meta-Path for _ in range(P): self.gcn_level_embeddings.append(GCN(nfeat, nhid, act, bias=True)) for i, gcn_embedding_path in enumerate(self.gcn_level_embeddings): self.add_module('gcn_path_{}'.format(i), gcn_embedding_path) self.semantic_level_attention = SemanticAttentionLayer(nhid, shid)
def __init__(self,n_nb, n_in, n_h, activation, num_clusters, beta): super(GIC, self).__init__() self.gcn = GCN(n_in, n_h, activation) self.read = AvgReadout() self.sigm = nn.Sigmoid() self.disc = Discriminator(n_h) self.disc_c = Discriminator_cluster(n_h,n_h,n_nb,num_clusters) self.beta = beta self.cluster = Clusterator(n_h,num_clusters)
def __init__(self, args): super(modeler, self).__init__() self.args = args self.gcn = nn.ModuleList([GCN(args.ft_size, args.hid_units, args.activation, args.drop_prob, args.isBias) for _ in range(args.nb_graphs)]) self.disc = Discriminator(args.hid_units) self.H = nn.Parameter(torch.FloatTensor(1, args.nb_nodes, args.hid_units)) self.readout_func = self.args.readout_func if args.isAttn: self.attn = nn.ModuleList([Attention(args) for _ in range(args.nheads)]) if args.isSemi: self.logistic = LogReg(args.hid_units, args.nb_classes).to(args.device) self.init_weight()
def __init__(self, n_in, n_h, activation, critic="bilinear", dataset=None, attack_model=True): super(DGI, self).__init__() self.gcn = GCN(n_in, n_h, activation) self.read = AvgReadout() self.sigm = nn.Sigmoid() self.disc = Discriminator(n_h, critic=critic, dataset=dataset, attack_model=attack_model)
def get_gcn_basic(n_nodes, n_features, num_classes): node_features_input_layer = layers.Input(shape=(n_nodes, n_features), name='node_feature_input') adjacency_matrix_input_layer = layers.Input(shape=(n_nodes, n_nodes), name='adjacency_matrix_input') # convolutional block 1 x = GCN(32, "relu")([node_features_input_layer, adjacency_matrix_input_layer]) # x = layers.Dropout(rate=0.3)(x) # sum-pooling and dense connection to output nodes x = SumPool(32)(x) x = layers.Dense(num_classes, activation="softmax")(x) model = tf.keras.Model(inputs=[node_features_input_layer, adjacency_matrix_input_layer], outputs=[x]) return model
def __init__(self, backbone='vgg', is_training=True): super().__init__() self.k_at_hop = [8, 4] self.post_dim = 120 self.active_connection = 3 self.is_training = is_training self.backbone_name = backbone self.fpn = FPN(self.backbone_name, self.is_training) self.gcn_model = GCN(600, 32) # 600 = 480 + 120 self.pooling = RROIAlign((3, 4), 1.0 / 1) # (32+8)*3*4 =480 # ##class and regression branch self.out_channel = 8 self.predict = nn.Sequential( # nn.Conv2d(32, 16, kernel_size=3, stride=1, padding=1), nn.Conv2d(32, self.out_channel, kernel_size=1, stride=1, padding=0)) self.graph = Graph_RPN(self.pooling, 120)
def get_chordal_two_model(n_nodes, n_features, num_classes): """ Returns a model specifically tailored to classify the chordal two dataset. :param n_nodes: number of nodes :param n_features: number of features :param num_classes: number of target classes :return: tf model """ node_features_input_layer = layers.Input(shape=(n_nodes, n_features), name='node_feature_input') adjacency_matrix_input_layer = layers.Input(shape=(n_nodes, n_nodes), name='adjacency_matrix_input') x = GCN(64, "relu")([node_features_input_layer, adjacency_matrix_input_layer]) x = layers.Dropout(rate=0.2)(x) x = SumPool(64)(x) x = layers.Dense(num_classes, activation="softmax")(x) model = tf.keras.Model(inputs=[node_features_input_layer, adjacency_matrix_input_layer], outputs=[x]) return model
def __init__(self, ft_size, hid_units): super(modeler, self).__init__() self.gcn = GCN(ft_size, hid_units) self.disc = InterDiscriminator(hid_units, ft_size)
def __init__(self, n_in, n_h, n_out, activation): super(GAE, self).__init__() self.hid = GCN(n_in, n_h, activation) self.out = GCN(n_h, n_out, act=lambda x: x) self.rec = InnerProductDecoder(act=lambda x: x)
def __init__(self, n_in, n_h, activation): super(Encoder, self).__init__() self.gcn = GCN(n_in, n_h, activation) self.mu = GCN(n_h, n_h * 2, activation) self.logvar = GCN(n_h, n_h * 2, activation)
def __init__(self, hidden_size, config, module_type): super(CognitiveGNN, self).__init__() self.gcn = GCN(hidden_size) self.both_net = MLP((hidden_size, hidden_size, 1)) self.select_net = MLP((hidden_size, hidden_size, 1)) self.module_type = module_type
def __init__(self, n_in, n_h, activation): self.gcn = GCN(n_in, n_h, activation) self.read = AvgReadout()
def __init__(self, n_features, n_hidden): super(DGI, self).__init__() self.gcn = GCN(n_features, n_hidden) self.readout = Readout() self.sigmoid = nn.Sigmoid() self.discriminator = Discriminator(n_hidden)