Download annotations/annotation_30/ARC/utils.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 6.14 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_30/ARC/utils.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_30/ARC/utils.py
-
curl -L -o utils.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_30/ARC/utils.py
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 |