【代码复现】AGC-DRR__Attributed Graph Clustering with Dual Redundancy Reduction（IJCAI-2022）
【代码复现】AGC-DRR__Attributed Graph Clustering with Dual Redundancy Reduction（IJCAI-2022）
文章目录
- 【代码复现】AGC-DRR__Attributed Graph Clustering with Dual Redundancy Reduction（IJCAI-2022）
-
- 1. 介绍
- 2. 前言
- 3. 复现代码
-
- 3.1 项目框架
- 3.2 代码文件
-
- 3.2.1 main.py
- 3.2.2 utils.py
- 3.2.3 train.py
- 3.2.4 opt.py
- 3.2.5 GAE.py
- 3.2.6 view_learner.py
- 3.3 实验结果
- 4. 参考
1. 介绍
本文复现的代码为论文----Attributed Graph Clustering with Dual Redundancy Reduction（IJCAI-2022）。
属性图聚类是图数据探索的一种基本而又必要的方法。最近在图对比学习方面的努力已经取得了令人印象深刻的聚类性能。然而，作者观察到：
- 普遍采用的InfoMax操作倾向于捕获冗余信息，限制了下游集群性能。
为此，作者开发了一种新的方法，称为双冗余减少的属性图聚类（AGC-DRR），以减少输入空间和潜在特征空间中的信息冗余。特别地，
- 为了减少输入空间的冗余，引入了一种对抗性学习机制来自适应地学习冗余的掉边矩阵，以确保比较样本对的多样性。
- 为了减少潜在空间中的冗余度，作者强制使用交叉增强样本嵌入的相关矩阵来近似一个单位矩阵。
- 基于此，学习到的网络在区分不同样本的同时，必须对扰动具有鲁棒性。
- 大量的实验已经证明，AGC-DRR在大多数基准测试上优于最先进的聚类方法。
2. 前言
- 任务所用一些数据集，可以参考常用图数据集。
- 论文的详细讲解见：AGC-DRR解读。
3. 复现代码
3.1 项目框架
dataset文件夹参考：常用图数据集。
3.2 代码文件
3.2.1 main.py
import opt
import torch
import numpy as np
from GAE import IGAE,IGAE_encoder
from view_learner import ViewLearner
from utils import *
from train import Train_gae
from sklearn.decomposition import PCA
import warnings
'''
main.py
'''
# 忽略警告，警告不必输出
warnings.filterwarnings('ignore')
setup()
print("use cuda: {}".format(opt.args.cuda))
device = opt.args.device
# 读取图数据集
x, y, adj = load_graph_data(opt.args.name)
# PCA降维
pca1 = PCA(n_components=opt.args.n_components)
x1 = pca1.fit_transform(x)
edge_index1 = np.array(adj.nonzero())
adj = normlize_adj(adj, True)
data = torch.from_numpy(x1).float()
adj = torch.from_numpy(adj).float()
adj = adj.to_dense()
model_gae = IGAE(
gae_n_enc_1=opt.args.gae_n_enc_1,
gae_n_enc_2=opt.args.gae_n_enc_2,
gae_n_enc_3=opt.args.gae_n_enc_3,
n_input=data.shape[1]
).to(device)
view_learner = ViewLearner(
IGAE_encoder(gae_n_enc_1=opt.args.gae_n_enc_1,
gae_n_enc_2=opt.args.gae_n_enc_2,
gae_n_enc_3=opt.args.gae_n_enc_3,
n_input=data.shape[1]),
).to(device)
Train_gae(model_gae, view_learner, data.to(device), adj.to(device), y, edge_index1)
3.2.2 utils.py
import numpy as np
import scipy.sparse as sp
import torch
import random
import opt
import numpy as np
from sklearn import metrics
from munkres import Munkres
import torch.nn.functional as F
from sklearn.cluster import KMeans
from sklearn.metrics import adjusted_rand_score as ari_score
from sklearn.metrics.cluster import normalized_mutual_info_score as nmi_score
'''
utils.py
'''
# set up--------------------------------------------------------------------------start
def setup():
setup_seed(np.random.randint(1000))
if opt.args.name == 'acm':
print('acm...............')
opt.args.n_clusters = 3
opt.args.t = 2
opt.args.view_lr = 1e-4
opt.args.lr = 5e-4
# opt.args.n_input = 100
elif opt.args.name == 'dblp':
print('dblp...............')
opt.args.n_clusters = 4
opt.args.t = 2
opt.args.view_lr = 1e-4
opt.args.lr = 5e-4
# opt.args.n_input = 50
elif opt.args.name == 'amap':
print('amap...............')
opt.args.n_clusters = 8
opt.args.t = 5
opt.args.view_lr = 1e-4
opt.args.lr = 5e-4
elif opt.args.name == 'cite':
print('cite...............')
opt.args.n_clusters = 6
opt.args.t = 2
opt.args.view_lr = 1e-3
opt.args.lr = 1e-4
elif opt.args.name == 'cora':
print('cora...............')
opt.args.n_clusters = 7
opt.args.t = 2
opt.args.view_lr = 1e-4
opt.args.lr = 5e-4
elif opt.args.name == 'corafull':
print('corafull...............')
opt.args.n_clusters = 70
opt.args.t = 2
opt.args.view_lr = 1e-4
opt.args.lr = 5e-4
else:
print("error!")
exit(0)
opt.args.device = torch.device(f"cuda:{opt.args.gpu}" if opt.args.cuda else "cpu")
def setup_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
# set up-------------------------------------------------------------------------------end
# torch-numpy transform--------------------------------------------------------------start
def numpy_to_torch(a, sparse=False):
if sparse:
a = torch.sparse.Tensor(a)
a = a.to_sparse()
else:
a = torch.FloatTensor(a)
return a
def torch_to_numpy(t):
return t.numpy()
# torch-numpy transform----------------------------------------------------------------end
def load_graph_data(dataset_name, show_details=False):
load_path = "dataset/" + dataset_name + "/" + dataset_name
feat = np.load(load_path+"_feat.npy", allow_pickle=True)
label = np.load(load_path+"_label.npy", allow_pickle=True)
adj = np.load(load_path+"_adj.npy", allow_pickle=True)
if show_details:
print("-----details of graph dataset------")
print("dataset name: ", dataset_name)
print("feature shape: ", feat.shape)
print("label shape: ", label.shape)
print("adj shape: ", adj.shape)
print("undirected edge num: ", int(np.nonzero(adj)[0].shape[0]/2))
print("category num: ", max(label)-min(label)+1)
print("category distribution: ")
for i in range(max(label)+1):
print("label", i, end=":")
print(len(label[np.where(label == i)]))
print("++++++++++++++++++++++++++++++")
opt.args.n_input = feat.shape[1]
return feat, label, adj
def new_graph(edge_index, weight, n, device):
edge_index = edge_index.cpu().numpy()
indices = torch.from_numpy(
np.vstack((edge_index[0], edge_index[1])).astype(np.int64)).to(device)
values = weight
shape = torch.Size((n,n))
return torch.sparse.FloatTensor(indices, values, shape)
def adjust_learning_rate(optimizer, epoch):
lr = 0.001 * (0.1 ** (epoch // 50))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
def parameter(model):
params = list(model.parameters())
k = 0
for i in params:
l = 1
for j in i.size():
l *= j
k = k + l
print("sum:" + str(k))
return str(k)
# load model parameter------------------------------------------------------------------start
def load_pretrain_parameter(model):
pretrained_dict = torch.load('model_pretrain/{}_pretrain.pkl'.format(opt.args.name), map_location='cpu')
model_dict = model.state_dict()
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
return model
def model_init(model, X, y):
model = load_pretrain_parameter(model)
with torch.no_grad():
Z1, Z2, Z, Q, X_ = model(X)
acc, nmi, ari, f1, centers = clustering(Z, y)
return centers
# load model parameter--------------------------------------------------------------------end
# Two methods to add nosie--------------------------------------------------------------start
def gaussian_noised_feature(X):
"""
add gaussian noise to the attribute matrix X
Args:
X: the attribute matrix
Returns: the noised attribute matrix Y
"""
N = torch.Tensor(np.random.normal(0, 0.01, X.shape)).to(opt.args.device)
Y = X + N
return Y
def gaussian_noised_feature_(X):
"""
add gaussian noise to the attribute matrix X
Args:
X: the attribute matrix
Returns: the noised attribute matrix Y
"""
N = torch.Tensor(np.random.normal(1, 0.01, X.shape)).to(opt.args.device)
Y = X * N
return Y
# Two methods to add nosie----------------------------------------------------------------end
# Norm something------------------------------------------------------------------------start
def normlize_adj(adj, symmetry = True):
adj = adj + np.eye(adj.shape[0])
# calculate degree matrix and it's inverse matrix
row_sum = adj.sum(1)
if symmetry:
d1 = np.diag(np.power(row_sum, -0.5))
norm_adj = np.matmul(np.matmul(d1, adj), d1) # symmetry normalize: D^{-0.5} A D^{-0.5}
else:
d2 = np.diag(np.power(row_sum, -1))
norm_adj = np.matmul(d2, adj) # non-symmetry normalize: D^{-1} A
return norm_adj
def normalize(mx):
rowsum = np.array(mx.sum(1))
r_inv = np.power(rowsum, -1).flatten()
r_inv[np.isinf(r_inv)] = 0.
r_mat_inv = sp.diags(r_inv)
mx = r_mat_inv.dot(mx)
return mx
def normalize_lap_(adj, self_loop=True, symmetry=False):
ident = np.eye(adj.shape[0])
if self_loop:
adj_tmp = adj + ident
else:
adj_tmp = adj
# calculate degree matrix and it's inverse matrix
row_sum = adj_tmp.sum(1)
L = np.diag(row_sum) - adj_tmp
if symmetry:
d1 = np.diag(np.power(row_sum, -0.5))
norm_L = np.matmul(np.matmul(d1, L), d1) # symmetry normalize: D^{-0.5} A D^{-0.5}
else:
d2 = np.diag(np.power(row_sum, -1))
norm_L = np.matmul(d2, L) # non-symmetry normalize: D^{-1} A
return norm_L
def get_adjs(adj, norm = True):
ident = 1 * np.eye(adj.shape[0])
norm_L = normalize_lap_(adj, True, norm)
reg = [1] * (2)
adjs = []
for i in range(len(reg)):
adjs.append(ident-(reg[i] * norm_L))
return adjs
def get_laps(adj, norm = True):
norm_L = normalize_lap_(adj, True, norm)
laps = []
t = 2
for i in range(t):
laps.append(norm_L)
return laps
# Norm something------------------------------------------------------------------------end
# Calculating loss---------------------------------------------------------------------start
def target_distribution(Q):
weight = Q ** 2 / Q.sum(0)
P = (weight.t() / weight.sum(1)).t()
return P
def cross_correlation(X, Y):
return torch.mm(X, Y.t())
def cross_view_loss(X, Y, A):
S = cross_correlation(X, Y)
L_cv = (A-S).pow(2).mean()
return L_cv
def distribution_loss(Q, P):
loss = F.kl_div(Q.log(), P, reduction='batchmean')
return loss
def reconstruction_loss(X, X_):
loss_rec = F.mse_loss(X, X_)
return loss_rec
# Calculating loss-----------------------------------------------------------------------end
# Clustering and Evaluation-------------------------------------------------------------start
def clustering(Z, y):
model = KMeans(n_clusters=opt.args.n_clusters, n_init=20)
cluster_id = model.fit_predict(Z.data.cpu().numpy())
acc, nmi, ari, f1 = eva(y, cluster_id, show_details=opt.args.show_details)
return acc, nmi, ari, f1, model.cluster_centers_
def cluster_acc(y_true, y_pred):
y_true = y_true - np.min(y_true)
l1 = list(set(y_true))
num_class1 = len(l1)
l2 = list(set(y_pred))
num_class2 = len(l2)
ind = 0
if num_class1 != num_class2:
for i in l1:
if i in l2:
pass
else:
y_pred[ind] = i
ind += 1
l2 = list(set(y_pred))
numclass2 = len(l2)
if num_class1 != numclass2:
print('error')
return
cost = np.zeros((num_class1, numclass2), dtype=int)
for i, c1 in enumerate(l1):
mps = [i1 for i1, e1 in enumerate(y_true) if e1 == c1]
for j, c2 in enumerate(l2):
mps_d = [i1 for i1 in mps if y_pred[i1] == c2]
cost[i][j] = len(mps_d)
m = Munkres()
cost = cost.__neg__().tolist()
indexes = m.compute(cost)
new_predict = np.zeros(len(y_pred))
for i, c in enumerate(l1):
c2 = l2[indexes[i][1]]
ai = [ind for ind, elm in enumerate(y_pred) if elm == c2]
new_predict[ai] = c
acc = metrics.accuracy_score(y_true, new_predict)
f1_macro = metrics.f1_score(y_true, new_predict, average='macro')
return acc, f1_macro
def eva(y_true, y_pred, show_details=False):
acc, f1 = cluster_acc(y_true, y_pred)
nmi = nmi_score(y_true, y_pred, average_method='arithmetic')
ari = ari_score(y_true, y_pred)
if show_details:
print(':acc {:.4f}'.format(acc), ', nmi {:.4f}'.format(nmi), ', ari {:.4f}'.format(ari),
', f1 {:.4f}'.format(f1))
return acc, nmi, ari, f1
# Clustering and Evaluation----------------------------------------------------------------end
3.2.3 train.py
import torch
from opt import args
from utils import *
from torch.optim import Adam
import torch.nn.functional as F
'''
train.py
'''
def Train_gae(model, view_learner, data, adj, label, edge_index):
acc_reuslt = []
nmi_result = []
ari_result = []
f1_result = []
view_optimizer = torch.optim.Adam(view_learner.parameters(), lr=args.view_lr)
optimizer = Adam(model.parameters(), lr=args.lr)
n = data.shape[0]
model.eval()
for epoch in range(args.epoch):
# ----------------------Training view_learner---------------------
view_learner.train()
view_learner.zero_grad()
z_igae, c = model(data, adj)
edge_logits = view_learner(data, adj, edge_index)
batch_aug_edge_weight = torch.sigmoid(edge_logits).squeeze() # p
aug_adj= new_graph(torch.tensor(edge_index).to('cuda'),batch_aug_edge_weight,n,'cuda')
aug_adj = aug_adj.to_dense()
aug_adj = aug_adj * adj
aug_adj = aug_adj.cpu().detach().numpy() + np.eye(n)
aug_adj = torch.from_numpy(normalize(aug_adj)).to(torch.float32).to('cuda')
aug_z_igae, aug_c = model(data, aug_adj)
edge_drop_out_prob = 1 - batch_aug_edge_weight
reg = edge_drop_out_prob.mean()
view_loss = (args.reg_lambda * reg) + model.calc_loss(c.T, aug_c.T) + model.calc_loss(c, aug_c)
(-view_loss).backward()
view_optimizer.step()
# ----------------------Training model---------------------
view_learner.eval()
model.train()
model.zero_grad()
z_igae, c = model(data, adj)
edge_logits = view_learner(data, adj, edge_index)
batch_aug_edge_weight = torch.sigmoid(edge_logits).squeeze() # p
aug_adj = new_graph(torch.tensor(edge_index).to('cuda'), batch_aug_edge_weight, n,'cuda')
aug_adj = aug_adj.to_dense()
aug_adj = aug_adj * adj
aug_adj = aug_adj.cpu().detach().numpy() + np.eye(n)
aug_adj = torch.from_numpy(normalize(aug_adj)).to(torch.float32).to('cuda')
aug_z_igae, aug_c = model(data, aug_adj)
z_mat = torch.matmul(z_igae, aug_z_igae.T)
model_loss = model.calc_loss(c.T, aug_c.T) + F.mse_loss(z_mat, torch.eye(n).to('cuda')) + model.calc_loss(c, aug_c)
model_loss.backward()
optimizer.step()
model.eval()
# ---------------------evaluation----------------------------
print('{} loss: {}'.format(epoch, model_loss))
z = (c + aug_c)/2
i = z.argmax(dim=-1)
acc, nmi, ari, f1 = eva(label, i.data.cpu().numpy(), epoch)
acc_reuslt.append(acc)
nmi_result.append(nmi)
ari_result.append(ari)
f1_result.append(f1)
return acc_reuslt, nmi_result, ari_result, f1_result
3.2.4 opt.py
import argparse
'''
opt.py
'''
parser = argparse.ArgumentParser(description='AGC-DRR', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--name', type=str, default='dblp')
parser.add_argument('--lr', type=float, default=1e-4)
parser.add_argument('--k', type=int, default=None)
parser.add_argument('--n_clusters', type=int, default=3)
parser.add_argument('--n_z', type=int, default=10)
parser.add_argument('--n_input', type=int, default=100)
parser.add_argument('--gamma_value', type=float, default=1)
parser.add_argument('--data_path', type=str, default='.txt')
parser.add_argument('--label_path', type=str, default='.txt')
parser.add_argument('--save_path', type=str, default='.txt')
parser.add_argument('--cuda', type=bool, default=True)
parser.add_argument('--gpu', type=int, default=0)
parser.add_argument('--n_components', type=int, default=50)
parser.add_argument('--batch_size', type=int, default=1600)
parser.add_argument('--epoch', type=int, default=400)
parser.add_argument('--acc', type=float, default=-1)
parser.add_argument('--shuffle', type=bool, default=True)
parser.add_argument('--gae_n_enc_1', type=int, default=1000)
parser.add_argument('--gae_n_enc_2', type=int, default=500)
parser.add_argument('--gae_n_enc_3', type=int, default=500)
parser.add_argument('--emb_dim', type=int, default=500,help='embedding dimension')
parser.add_argument('--dataset', type=str, default='ogbg-molesol',help='Dataset')
parser.add_argument('--view_lr', type=float, default=1e-4,help='View Learning rate.')
parser.add_argument('--num_gc_layers', type=int, default=5,help='Number of GNN layers before pooling')
parser.add_argument('--pooling_type', type=str, default='standard',help='GNN Pooling Type Standard/Layerwise')
parser.add_argument('--mlp_edge_model_dim', type=int, default=128,help='embedding dimension')
parser.add_argument('--pred_dim', type=int, default=64,help='embedding dimension')
parser.add_argument('--drop_ratio', type=float, default=0.0,help='Dropout Ratio / Probability')
parser.add_argument('--reg_lambda', type=float, default=1, help='View Learner Edge Perturb Regularization Strength')
parser.add_argument('--seed', type=int, default=0)
args = parser.parse_args()
3.2.5 GAE.py
import torch
from torch import nn
import torch.nn.functional as F
from torch.nn import Module, Parameter, Dropout
from opt import args
'''
GAE.py
'''
class GNNLayer(Module):
def __init__(self, in_features, out_features):
super(GNNLayer, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.w = Parameter(torch.FloatTensor(out_features, in_features))
self.act = nn.Tanh()
torch.nn.init.xavier_uniform_(self.w)
def forward(self, features, adj, active):
if active:
support = self.act(F.linear(features, self.w)) # add bias
else:
support = F.linear(features, self.w) # add bias
output = torch.mm(adj, support)
return output
class IGAE_encoder(nn.Module):
def __init__(self, gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, n_input):
super(IGAE_encoder, self).__init__()
self.gnn_1 = GNNLayer(n_input, gae_n_enc_1)
self.gnn_2 = GNNLayer(gae_n_enc_1, gae_n_enc_2)
self.gnn_3 = GNNLayer(gae_n_enc_2, gae_n_enc_3)
self.s = nn.Sigmoid()
def forward(self, x, adj):
z = self.gnn_1(x, adj, active=True)
z = self.gnn_2(z, adj, active=True)
z_igae = self.gnn_3(z, adj, active=False)
return z_igae
class Cluster_layer(nn.Module):
def __init__(self, in_dims, out_dims):
super(Cluster_layer, self).__init__()
self.l = nn.Sequential(nn.Linear(in_dims, out_dims),
nn.Softmax())
def forward(self, h):
c = self.l(h)
return c
class IGAE(nn.Module):
def __init__(self, gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, n_input):
super(IGAE, self).__init__()
self.encoder = IGAE_encoder(
gae_n_enc_1=gae_n_enc_1,
gae_n_enc_2=gae_n_enc_2,
gae_n_enc_3=gae_n_enc_3,
n_input=n_input,
)
self.cluster = Cluster_layer(
in_dims=gae_n_enc_3,
out_dims=args.n_clusters,
)
def forward(self, x, adj):
z_igae = self.encoder(x, adj)
c = self.cluster(z_igae)
return z_igae, c
@staticmethod
def calc_loss(x, x_aug, temperature=0.2, sym=True):
batch_size = x.shape[0]
x_abs = x.norm(dim=1)
x_aug_abs = x_aug.norm(dim=1)
sim_matrix = torch.einsum('ik,jk->ij', x, x_aug) / torch.einsum('i,j->ij', x_abs, x_aug_abs)
sim_matrix = torch.exp(sim_matrix / temperature)
pos_sim = sim_matrix[range(batch_size), range(batch_size)]
if sym:
loss_0 = pos_sim / (sim_matrix.sum(dim=0) - pos_sim)
loss_1 = pos_sim / (sim_matrix.sum(dim=1) - pos_sim)
# print(pos_sim, sim_matrix.sum(dim=0))
loss_0 = - torch.log(loss_0).mean()
loss_1 = - torch.log(loss_1).mean()
loss = (loss_0 + loss_1) / 2.0
else:
loss = pos_sim / (sim_matrix.sum(dim=1) - pos_sim)
loss = - torch.log(loss).mean()
return loss
3.2.6 view_learner.py
import torch
from torch.nn import Sequential, Linear, ReLU
from opt import args
'''
View_Learner.py
'''
class ViewLearner(torch.nn.Module):
def __init__(self, encoder, mlp_edge_model_dim=64):
super(ViewLearner, self).__init__()
self.encoder = encoder
self.input_dim = args.emb_dim
self.mlp_edge_model = Sequential(
Linear(self.input_dim * 2, 1),
# ReLU(),
# Linear(mlp_edge_model_dim, 1)
)
self.init_emb()
def init_emb(self):
for m in self.modules():
if isinstance(m, Linear):
torch.nn.init.xavier_uniform_(m.weight.data)
if m.bias is not None:
m.bias.data.fill_(0.0)
def forward(self, x, adj, edge_index):
node_emb= self.encoder(x, adj)
src, dst = edge_index[0], edge_index[1]
emb_src = node_emb[src]
emb_dst = node_emb[dst]
# print(emb_src.shape)
edge_emb = torch.cat([emb_src, emb_dst], 1)
# print(edge_emb.shape)
edge_logits = self.mlp_edge_model(edge_emb)
return edge_logits
3.3 实验结果
4. 参考
【1】https://blog.csdn.net/qq_51392112/article/details/129429108
【2】https://blog.csdn.net/qq_51392112/article/details/129298794