mcy98's picture
Upload folder using huggingface_hub
e89a301 verified
Raw History Blame Contribute Delete
6.14 kB
import random
import torch
import os
from torch_geometric.data import Data
import json
from sklearn.decomposition import PCA
from sklearn.random_projection import GaussianRandomProjection
import numpy as np
import scipy.io as sio
import scipy.sparse as sp
from sklearn.metrics import roc_auc_score, average_precision_score
def test_eval(labels, probs):
score = {}
with torch.no_grad():
if torch.is_tensor(labels):
labels = labels.cpu().numpy()
if torch.is_tensor(probs):
probs = probs.cpu().numpy()
score['AUROC'] = roc_auc_score(labels, probs)
score['AUPRC'] = average_precision_score(labels, probs)
return score
def sparse_mx_to_torch_sparse_tensor(sparse_mx):
"""Convert a scipy sparse matrix to a torch sparse tensor."""
sparse_mx = sparse_mx.tocoo().astype(np.float32)
indices = torch.from_numpy(
np.vstack((sparse_mx.row, sparse_mx.col)).astype(np.int64))
values = torch.from_numpy(sparse_mx.data)
shape = torch.Size(sparse_mx.shape)
return torch.sparse.FloatTensor(indices, values, shape)
def feat_alignment(X, edges, dims):
edge_src, edge_dst = edges
num_edges = len(edge_src)
if X.shape[1] < dims:
transformer = GaussianRandomProjection(n_components=256, random_state=0)
X = transformer.fit_transform(X.cpu().numpy())
# Proj
pca = PCA(n_components=dims, random_state=0)
X_transformed = pca.fit_transform(X)
X_transformed = torch.FloatTensor(X_transformed)
# normalize
X_min, _ = torch.min(X_transformed, dim=0)
X_max, _ = torch.max(X_transformed, dim=0)
X_s = (X_transformed - X_min) / (X_max - X_min)
smooth_coefficients = torch.zeros(X_transformed.shape[1])
for k in range(X_transformed.shape[1]):
# X_{i k}-X_{j k}, (v_i, v_j) \in Edge set
differences = X_s[edge_src, k] - X_s[edge_dst, k]
smooth_coefficients[k] = torch.sum(differences ** 2) / num_edges
# sort
_, sorted_indices = torch.sort(smooth_coefficients)
X_reordered = X_transformed[:, sorted_indices]
return X_reordered
def preprocess_features(features):
"""Row-normalize feature matrix and convert to tuple representation"""
rowsum = np.array(features.sum(1))
r_inv = np.power(rowsum, -1).flatten()
r_inv[np.isinf(r_inv)] = 0.
r_mat_inv = sp.diags(r_inv)
features = r_mat_inv.dot(features)
return features.todense()
def normalize_adj(adj):
"""Symmetrically normalize adjacency matrix."""
adj = sp.coo_matrix(adj)
rowsum = np.array(adj.sum(1))
d_inv_sqrt = np.power(rowsum, -0.5).flatten()
d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.
d_mat_inv_sqrt = sp.diags(d_inv_sqrt)
return adj.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt).tocoo()
class Dataset:
def __init__(self, dims, name='cora', prefix='./dataset/'):
# initiation
self.shot_mask = None
self.shot_idx = None
self.graph = None
self.x_list = None
self.name = name
preprocess_filename = f'{prefix}{name}_{dims}.npz'
if os.path.exists(preprocess_filename):
with np.load(preprocess_filename, allow_pickle=True) as f:
data = f['data'].item()
feat = f['feat']
else:
data = sio.loadmat(f"{prefix + name}.mat")
adj = data['Network']
feat = data['Attributes']
adj_sp = sp.csr_matrix(adj)
row, col = adj_sp.nonzero()
edge_index = torch.tensor([row, col], dtype=torch.long)
if name in ['Amazon', 'YelpChi', 'tolokers', 'tfinance']:
feat = sp.lil_matrix(feat)
feat = preprocess_features(feat)
else:
feat = sp.lil_matrix(feat).toarray()
feat = torch.FloatTensor(feat)
feat = feat_alignment(feat, edge_index, dims)
np.savez(preprocess_filename, data=data, feat=feat)
adj = data['Network'] if 'Network' in data else data['A']
if name in ['YelpChi', 'Facebook']:
adj_norm = normalize_adj(adj)
else:
adj_norm = normalize_adj(adj + sp.eye(adj.shape[0]))
adj_norm = sparse_mx_to_torch_sparse_tensor(adj_norm)
label = data['Label'] if ('Label' in data) else data['gnd']
self.label = label
self.adj_norm = adj_norm
self.feat = feat
ano_labels = torch.tensor(np.squeeze(np.array(self.label)), dtype=torch.float)
# Create a PyTorch Geometric Data object
data = Data(x=torch.tensor(self.feat, dtype=torch.float),
x_list=self.x_list,
adj=self.adj_norm,
ano_labels=ano_labels,
shot_idx=self.shot_idx,
shot_mask=self.shot_mask
)
self.graph = data
def few_shot(self, shot=10):
y = self.graph.ano_labels
num_nodes = y.shape[0]
normal_idx = torch.where(y == 0)[0].tolist()
random.shuffle(normal_idx)
shot_idx = torch.tensor(normal_idx[:shot])
shot_mask = torch.zeros(num_nodes, dtype=torch.bool)
self.graph.shot_idx = shot_idx
shot_mask[shot_idx] = True
self.graph.shot_mask = shot_mask
def propagated(self, k):
x = torch.FloatTensor(self.feat).cuda()
h_list = [x]
for _ in range(k):
h_list.append(torch.spmm(self.adj_norm.cuda(), h_list[-1]))
self.graph.x_list = h_list
def read_json(model, shot, json_dir):
# Construct the filename based on the dataset name and shot
filename = f"{json_dir}/{model}_{shot}.json"
# Check if the file exists
if os.path.exists(filename):
# Read the JSON file and return the dictionary
with open(filename, 'r') as file:
try:
data = json.load(file)
return data
except json.JSONDecodeError as e:
print(f"Error decoding JSON file {filename}: {e}")
return None
else:
print(f"JSON file {filename} not found.")
return None