1.utils.py
import numpy as np import pickle as pkl import networkx as nx import scipy.sparse as sp from scipy.sparse.linalg.eigen.arpack import eigsh import sys from scipy.sparse.linalg import norm as sparsenorm from scipy.linalg import qr import math def parse_index_file(filename): """Parse index file.""" index = [] for line in open(filename): index.append(int(line.strip())) return index def sample_mask(idx, l): """Create mask.""" mask = np.zeros(l) mask[idx] = 1 return np.array(mask, dtype=np.bool) def load_data(dataset_str): """Load data.""" names = ['x', 'y', 'tx', 'ty', 'allx', 'ally', 'graph'] objects = [] for i in range(len(names)): with open("data/ind.{}.{}".format(dataset_str, names[i]), 'rb') as f: if sys.version_info > (3, 0): objects.append(pkl.load(f, encoding='latin1')) else: objects.append(pkl.load(f)) x, y, tx, ty, allx, ally, graph = tuple(objects) test_idx_reorder = parse_index_file( "data/ind.{}.test.index".format(dataset_str)) test_idx_range = np.sort(test_idx_reorder) if dataset_str == 'citeseer': # Fix citeseer dataset (there are some isolated nodes in the graph) # Find isolated nodes, add them as zero-vecs into the right position test_idx_range_full = range( min(test_idx_reorder), max(test_idx_reorder)+1) tx_extended = sp.lil_matrix((len(test_idx_range_full), x.shape[1])) tx_extended[test_idx_range-min(test_idx_range), :] = tx tx = tx_extended ty_extended = np.zeros((len(test_idx_range_full), y.shape[1])) ty_extended[test_idx_range-min(test_idx_range), :] = ty ty = ty_extended features = sp.vstack((allx, tx)).tolil() features[test_idx_reorder, :] = features[test_idx_range, :] adj = nx.adjacency_matrix(nx.from_dict_of_lists(graph)) labels = np.vstack((ally, ty)) labels[test_idx_reorder, :] = labels[test_idx_range, :] idx_test = test_idx_range.tolist() idx_train = range(len(ally)-500) idx_val = range(len(ally)-500, len(ally)) train_mask = sample_mask(idx_train, labels.shape[0]) val_mask = sample_mask(idx_val, labels.shape[0]) test_mask = sample_mask(idx_test, labels.shape[0]) y_train = np.zeros(labels.shape) y_val = np.zeros(labels.shape) y_test = np.zeros(labels.shape) y_train[train_mask, :] = labels[train_mask, :] y_val[val_mask, :] = labels[val_mask, :] y_test[test_mask, :] = labels[test_mask, :] return adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask def load_data_original(dataset_str): """Load data.""" names = ['x', 'y', 'tx', 'ty', 'allx', 'ally', 'graph'] objects = [] for i in range(len(names)): with open("data/ind.{}.{}".format(dataset_str, names[i]), 'rb') as f: if sys.version_info > (3, 0): objects.append(pkl.load(f, encoding='latin1')) else: objects.append(pkl.load(f)) x, y, tx, ty, allx, ally, graph = tuple(objects) test_idx_reorder = parse_index_file( "data/ind.{}.test.index".format(dataset_str)) test_idx_range = np.sort(test_idx_reorder) if dataset_str == 'citeseer': # Fix citeseer dataset (there are some isolated nodes in the graph) # Find isolated nodes, add them as zero-vecs into the right position test_idx_range_full = range( min(test_idx_reorder), max(test_idx_reorder)+1) tx_extended = sp.lil_matrix((len(test_idx_range_full), x.shape[1])) tx_extended[test_idx_range-min(test_idx_range), :] = tx tx = tx_extended ty_extended = np.zeros((len(test_idx_range_full), y.shape[1])) ty_extended[test_idx_range-min(test_idx_range), :] = ty ty = ty_extended # features (2708,1433) labels (2708,7) features = sp.vstack((allx, tx)).tolil() features[test_idx_reorder, :] = features[test_idx_range, :] adj = nx.adjacency_matrix(nx.from_dict_of_lists(graph)) labels = np.vstack((ally, ty)) labels[test_idx_reorder, :] = labels[test_idx_range, :] idx_test = test_idx_range.tolist() idx_train = range(len(y)) idx_val = range(len(y), len(y)+500) train_mask = sample_mask(idx_train, labels.shape[0]) val_mask = sample_mask(idx_val, labels.shape[0]) test_mask = sample_mask(idx_test, labels.shape[0]) y_train = np.zeros(labels.shape) y_val = np.zeros(labels.shape) y_test = np.zeros(labels.shape) y_train[train_mask, :] = labels[train_mask, :] y_val[val_mask, :] = labels[val_mask, :] y_test[test_mask, :] = labels[test_mask, :] return adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask def sparse_to_tuple(sparse_mx): """Convert sparse matrix to tuple representation.""" def to_tuple(mx): if not sp.isspmatrix_coo(mx): mx = mx.tocoo() coords = np.vstack((mx.row, mx.col)).transpose() values = mx.data shape = mx.shape return coords, values, shape if isinstance(sparse_mx, list): for i in range(len(sparse_mx)): sparse_mx[i] = to_tuple(sparse_mx[i]) else: sparse_mx = to_tuple(sparse_mx) return sparse_mx def nontuple_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 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 sparse_to_tuple(features) 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() def nontuple_preprocess_adj(adj): """ 返回对称归一化的邻接矩阵 type:csr """ adj_normalized = normalize_adj(sp.eye(adj.shape[0]) + adj) return adj_normalized.tocsr() def column_prop(adj): """ detail reference: https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.linalg.norm.html#scipy.sparse.linalg.norm 等价于array形式: arr = np.array([[1, 4, 7], [2, 5, 8], [3, 6, 9]]) column_norm = np.linalg.norm(arr, axis=0) 对每一列求二范数 print column_norm >>> [ 3.74165739 8.77496439 13.92838828] => [sqrt(1^2+2^2+3^2) sqrt(4^2+5^2+6^2) sqrt(7^2+8^2+9^2)] norm_sum = sum(column_norm) # 归一化 print(column_norm/norm_sum) >>> [0.14148822 0.33181929 0.52669249] """ column_norm = sparsenorm(adj, axis=0) # column_norm = pow(sparsenorm(adj, axis=0),2) norm_sum = sum(column_norm) return column_norm/norm_sum def mix_prop(adj, features, sparseinputs=False): adj_column_norm = sparsenorm(adj, axis=0) if sparseinputs: features_row_norm = sparsenorm(features, axis=1) else: features_row_norm = np.linalg.norm(features, axis=1) mix_norm = adj_column_norm*features_row_norm norm_sum = sum(mix_norm) return mix_norm / norm_sum def preprocess_adj(adj): """Preprocessing of adjacency matrix for simple GCN model and conversion to tuple representation.""" adj_normalized = normalize_adj(sp.eye(adj.shape[0]) + adj) return sparse_to_tuple(adj_normalized) def dense_lanczos(A, K): q = np.random.randn(A.shape[0], ) Q, sigma = lanczos(A, K, q) A2 = np.dot(Q[:, :K], np.dot(sigma[:K, :K], Q[:, :K].T)) return sp.csr_matrix(A2) def sparse_lanczos(A, k): q = sp.random(A.shape[0], 1) n = A.shape[0] Q = sp.lil_matrix(np.zeros((n, k+1))) A = sp.lil_matrix(A) Q[:, 0] = q/sparsenorm(q) alpha = 0 beta = 0 for i in range(k): if i == 0: q = A*Q[:, i] else: q = A*Q[:, i] - beta*Q[:, i-1] alpha = q.T*Q[:, i] q = q - Q[:, i]*alpha q = q - Q[:, :i]*Q[:, :i].T*q # full reorthogonalization beta = sparsenorm(q) Q[:, i+1] = q/beta print(i) Q = Q[:, :k] Sigma = Q.T*A*Q A2 = Q[:, :k]*Sigma[:k, :k]*Q[:, :k].T return A2 # return Q, Sigma def dense_RandomSVD(A, K): G = np.random.randn(A.shape[0], K) B = np.dot(A, G) Q, R = qr(B, mode='economic') M = np.dot(Q, np.dot(Q.T, A)) return sp.csr_matrix(M) def construct_feed_dict(features, support, labels, labels_mask, placeholders): """Construct feed dictionary.""" feed_dict = dict() feed_dict.update({placeholders['labels']: labels}) feed_dict.update({placeholders['labels_mask']: labels_mask}) feed_dict.update({placeholders['features']: features}) feed_dict.update({placeholders['support'][i]: support[i] for i in range(len(support))}) feed_dict.update({placeholders['num_features_nonzero']: features[1].shape}) return feed_dict def chebyshev_polynomials(adj, k): """Calculate Chebyshev polynomials up to order k. Return a list of sparse matrices (tuple representation).""" print("Calculating Chebyshev polynomials up to order {}...".format(k)) adj_normalized = normalize_adj(adj) laplacian = sp.eye(adj.shape[0]) - adj_normalized largest_eigval, _ = eigsh(laplacian, 1, which='LM') scaled_laplacian = ( 2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0]) t_k = list() t_k.append(sp.eye(adj.shape[0])) t_k.append(scaled_laplacian) def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap): s_lap = sp.csr_matrix(scaled_lap, copy=True) return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two for i in range(2, k+1): t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian)) return sparse_to_tuple(t_k) def view_bar(message, num, total, loss, train_acc, val_acc, test_acc, times): rate = num / total rate_num = int(rate * 40) rate_nums = math.ceil(rate * 100) r = 'r%s:[%s%s]%d%%t%d/%d - loss:%.3f - train_acc:%.3f - val_acc:%.3f - test_acc:%.3f - time:%.2fs' % (message, "=" * rate_num, " " * (40 - rate_num), rate_nums, num, total, loss, train_acc, val_acc, test_acc, times) sys.stdout.write(r) sys.stdout.flush()
2.layers.py
import tensorflow as tf from model.inits import * from model.utils import * def sparse_dropout(x, keep_prob, noise_shape): """Dropout for sparse tensors.""" random_tensor = keep_prob random_tensor += tf.random.uniform(noise_shape) dropout_mask = tf.cast(tf.floor(random_tensor), dtype=tf.bool) pre_out = tf.sparse.retain(x, dropout_mask) return pre_out * (1./keep_prob) def dot(x, y, sparse=False): """Wrapper for tf.matmul (sparse vs dense).""" if sparse: res = tf.sparse.sparse_dense_matmul(x, y) else: res = tf.matmul(x, y) return res class Layer(object): def __init__(self, **kwargs): self.vars = {} def _call(self, params): """implement the layer operation """ return params def __call__(self, params): outputs = self._call(params) return outputs class Dense(Layer): def __init__(self, name, input_dim, output_dim, dropout=0.0, sparse_inputs=False, act=tf.nn.relu, bias=False, **kwargs): super(Dense, self).__init__(**kwargs) self.name = name self.dropout = dropout self.act = act self.out_dim = output_dim # bool self.bias = bias self.sparse_inputs = sparse_inputs # params['features'] sparse or not # define params self.vars['weight'] = glorot([input_dim, output_dim], name=self.name+'weight') if self.bias: self.vars['bias'] = zeros([output_dim], name=self.name+'bias') def _call(self, params): """params: features support """ x = params['features'] # dropout x if self.sparse_inputs: x = sparse_dropout(x, 1-self.dropout, params['num_features_nonzero']) else: x = tf.nn.dropout(x, 1-self.dropout) output = dot(x, self.vars['weight'], sparse=self.sparse_inputs) if self.bias: output += self.vars['bias'] return self.act(output) class GraphConvolution(Layer): def __init__(self, name, input_dim, output_dim, dropout=0.0, sparse_inputs=False, act=tf.nn.relu, bias=False, **kwargs): super(GraphConvolution, self).__init__(**kwargs) self.name = name self.dropout = dropout self.act = act self.out_dim = output_dim # bool self.bias = bias self.sparse_inputs = sparse_inputs # params['features'] sparse or not # define params self.vars['weight'] = glorot([input_dim, output_dim], name=self.name+'weight') if self.bias: self.vars['bias'] = zeros([output_dim], name=self.name+'bias') def _call(self, params): x = params['features'] support = params['support'] # dropout x if self.sparse_inputs: x = sparse_dropout(x, 1-self.dropout, params['num_features_nonzero']) else: x = tf.nn.dropout(x, 1-self.dropout) # x is sparse pre_sup = dot(x, self.vars['weight'], sparse=self.sparse_inputs) # x.dot(w) # support is sparse output = dot(support, pre_sup, sparse=True) # Axw if self.bias: output += self.vars['bias'] return self.act(output)
3.models.py
from model.layers import * from model.metrics import * import numpy as np class Model(object): def __init__(self): self.vars = [] self.layers = [] def forward(self): raise NotImplementedError def _update(self): raise NotImplementedError def _loss(self): raise NotImplementedError class GCN(Model): """ kipf & welling """ def __init__(self, placeholders, sparse_inputs=False): super(GCN, self).__init__() self.input_dim = placeholders['in_dim'] self.hid_dim = placeholders['hid_dim'] self.output_dim = placeholders['out_dim'] self.weight_decay = placeholders['weight_decay'] self.dropout = placeholders['dropout'] self.lr = placeholders['lr'] self.sparse_inputs = sparse_inputs # params['features'] sparse or not self.build() def build(self): """构建2 layer GCN, 并保存参数到vars中 第一层需要sparse_inputs 如果features是sparse,则features x W 要sparsedot 第二层不需要sparse_inputs 因为H0是dense的""" self.layers.append(GraphConvolution(name='GCN_0', input_dim=self.input_dim, output_dim=self.hid_dim, dropout=self.dropout, act=tf.nn.relu, sparse_inputs=self.sparse_inputs)) self.layers.append(GraphConvolution(name='GCN_1', input_dim=self.hid_dim, output_dim=self.output_dim, dropout=self.dropout, act=lambda x: x, sparse_inputs=False)) for layer in self.layers: for var in layer.vars.values(): self.vars.append(var) self.op = tf.optimizers.Adam(self.lr) def forward(self, params): # params: features support for layer in self.layers: hidden = layer(params) params.update({'features': hidden}) return hidden def _update(self, tape, loss): gradients = tape.gradient(target=loss, sources=self.vars) self.op.apply_gradients(zip(gradients, self.vars)) def _loss(self, outputs, labels, labels_mask): loss = masked_softmax_cross_entropy(outputs, labels, labels_mask) for var in self.vars: loss += self.weight_decay*tf.nn.l2_loss(var) # Cross entropy error return loss class FASTGCN(Model): def __init__(self, placeholders, sparse_inputs=False): super(FASTGCN, self).__init__() self.input_dim = placeholders['in_dim'] self.hid_dim = placeholders['hid_dim'] self.output_dim = placeholders['out_dim'] self.weight_decay = placeholders['weight_decay'] self.dropout = placeholders['dropout'] self.lr = placeholders['lr'] self.sparse_inputs = sparse_inputs # params['features'] sparse or not self.build() def build(self): """构建2 layer GCN, 并保存参数到vars中 第一层需要sparse_inputs 如果features是sparse,则features x W 要sparsedot 第二层不需要sparse_inputs 因为H0是dense的""" self.layers.append(Dense(name='Dense_0', input_dim=self.input_dim, output_dim=self.hid_dim, dropout=self.dropout, act=tf.nn.relu, sparse_inputs=self.sparse_inputs)) self.layers.append(GraphConvolution(name='GCN_1', input_dim=self.hid_dim, output_dim=self.output_dim, dropout=self.dropout, act=lambda x: x, sparse_inputs=False)) for layer in self.layers: for var in layer.vars.values(): self.vars.append(var) self.op = tf.optimizers.Adam(self.lr) def forward(self, params): # params: features support for layer in self.layers: hidden = layer(params) params.update({'features': hidden}) return hidden def _update(self, tape, loss): gradients = tape.gradient(target=loss, sources=self.vars) self.op.apply_gradients(zip(gradients, self.vars)) def _loss(self, outputs, labels): # batch outputs loss = softmax_cross_entropy(outputs, labels) for var in self.vars: loss += self.weight_decay*tf.nn.l2_loss(var) # Cross entropy error return loss
4.metrics.py
import tensorflow as tf def masked_softmax_cross_entropy(preds, labels, mask): """Softmax cross-entropy loss with masking.""" loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels) mask = tf.cast(mask, dtype=tf.float32) mask /= tf.reduce_mean(mask) loss *= mask # element-wise 把其它节点遮掉,只用train nodes来训练 return tf.reduce_mean(loss) def masked_accuracy(preds, labels, mask): """Accuracy with masking.""" correct_prediction = tf.equal(tf.argmax(preds, 1), tf.argmax(labels, 1)) accuracy_all = tf.cast(correct_prediction, tf.float32) mask = tf.cast(mask, dtype=tf.float32) mask /= tf.reduce_mean(mask) accuracy_all *= mask return tf.reduce_mean(accuracy_all) def softmax_cross_entropy(preds, labels): loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels) return tf.reduce_mean(loss) def accuracy(preds, labels): correct_prediction = tf.equal(tf.argmax(preds, 1), tf.argmax(labels, 1)) accuracy_all = tf.cast(correct_prediction, tf.float32) return tf.reduce_mean(accuracy_all)
5.inits.py
import tensorflow as tf import numpy as np def uniform(shape, scale=0.05, name=None): """Uniform init.""" initial = tf.random.uniform( shape, minval=-scale, maxval=scale, dtype=tf.float32) return tf.Variable(initial, name=name) def glorot(shape, name=None): """Glorot & Bengio (AISTATS 2010) init.""" init_range = np.sqrt(6.0/(shape[0]+shape[1])) initial = tf.random.uniform( shape, minval=-init_range, maxval=init_range, dtype=tf.float32) return tf.Variable(initial, name=name) def zeros(shape, name=None): """All zeros.""" initial = tf.zeros(shape, dtype=tf.float32) return tf.Variable(initial, name=name) def ones(shape, name=None): """All ones.""" initial = tf.ones(shape, dtype=tf.float32) return tf.Variable(initial, name=name)
6.main.py
from model.utils import * from model.metrics import * from model.models import FASTGCN import tensorflow as tf from scipy.sparse import csr_matrix import time def iterate_minibatches_listinputs(inputs, batchsize, shuffle=False): """ 对inputs: [normADJ_train, y_train]进行切片""" assert inputs is not None numSamples = inputs[0].shape[0] # 训练节点个数 if shuffle: indices = np.arange(numSamples) np.random.shuffle(indices) """ 步长为batchsize,如果需要shuffle 则对indices进行切片.否则直接按顺序切片. """ for start_idx in range(0, numSamples - batchsize + 1, batchsize): if shuffle: excerpt = indices[start_idx:start_idx + batchsize] else: """slice(start, stop, step) => start -- 起始位置 stop -- 结束位置 step -- 间距 """ excerpt = slice(start_idx, start_idx + batchsize) """ print(len(excerpt)) >>> 250 (batch_size) [input[excerpt] for input in inputs] => inputs由normADJ_train和y_train组成, input相当于normADJ_train或y_train,即分别对二者切片 """ yield [input[excerpt] for input in inputs] def construct_params(features, support): params = dict() params.update({'support': tf.cast(tf.SparseTensor( support[0], support[1], support[2]), tf.float32)}) params.update({'features': tf.cast(tf.SparseTensor( features[0], features[1], features[2]), tf.float32)}) params.update({'num_features_nonzero': features[1].shape}) return params if __name__ == "__main__": (adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask) = load_data('cora') """np.where 找出mask中为true的下标 """ train_index = np.where(train_mask)[0] y_train = y_train[train_index] val_index = np.where(val_mask)[0] y_val = y_val[val_index] test_index = np.where(test_mask)[0] y_test = y_test[test_index] """print(adj_train.shape, y_train.shape, y_test.shape, y_val.shape) >>> (1208, 1208) (1208, 7) (1000, 7) (500, 7) """ train_val_index = np.concatenate([train_index, val_index], axis=0) train_test_idnex = np.concatenate([train_index, test_index], axis=0) """preprocessing csr adj && features: print(csr_normADJ_train.shape, csr_normADJ_val.shape, csr_normADJ_test.shape) print(csr_features_train.shape,csr_features_val.shape, csr_features_test.shape) >>> (1208, 1208) (1708, 1708) (2208, 2208) >>> (1208, 1433) (1708, 1433) (2208, 1433)""" csr_normADJ_train = nontuple_preprocess_adj( adj[train_index, :][:, train_index]) # (1208, 1208) csr_normADJ_val = nontuple_preprocess_adj( adj[train_val_index, :][:, train_val_index]) # (1708, 1708) csr_normADJ_test = nontuple_preprocess_adj( adj[train_test_idnex, :][:, train_test_idnex]) # (2208, 2208) csr_features_train = nontuple_preprocess_features( features[train_index]) csr_features_val = nontuple_preprocess_features( features[train_val_index]) csr_features_test = nontuple_preprocess_features( features[train_test_idnex]) y_val = np.vstack((y_train, y_val)) y_test = np.vstack((y_train, y_test)) """ 计算每个节点的概率: q(u) = ||A(: , u)||^2 / sum(||A(: , v)||^2) """ p0 = column_prop(csr_normADJ_train) epochs = 200 samplesize = 50 placeholders = {'in_dim': 1433, 'hid_dim': 32, 'out_dim': 7, 'weight_decay': 5e-4, 'dropout': 0.5, 'lr': 0.01} dense_AXfeatures_train = csr_normADJ_train.dot( csr_features_train.todense()) dense_AXfeatures_val = csr_normADJ_val.dot( csr_features_val.todense()) dense_AXfeatures_test = csr_normADJ_test.dot( csr_features_test.todense()) """print(dense_AXfeatures_train.shape, dense_AXfeatures_val.shape, dense_AXfeatures_test.shape) >>> (1208, 1433) (1708, 1433) (2208, 1433)""" # transform into tuple tuple_AXfeatures_train = sparse_to_tuple( csr_matrix(dense_AXfeatures_train)) tuple_AXfeatures_val = sparse_to_tuple( csr_matrix(dense_AXfeatures_val)) tuple_AXfeatures_test = sparse_to_tuple( csr_matrix(dense_AXfeatures_test)) model = FASTGCN(placeholders, sparse_inputs=True) cost_val = [] t = time.time() for epoch in range(epochs): for batch in iterate_minibatches_listinputs([csr_normADJ_train, y_train], batchsize=1024, shuffle=True): [normADJ_batch, y_train_batch] = batch """get support_batch(tuple), features_inputs(tuple). """ if samplesize == -1: support_batch = sparse_to_tuple(normADJ_batch) features_inputs = sparse_to_tuple( csr_matrix(dense_AXfeatures_train)) else: distr = np.nonzero(np.sum(normADJ_batch, axis=0))[1] if samplesize > len(distr): q1 = distr else: q1 = np.random.choice( distr, samplesize, replace=False, p=p0[distr]/sum(p0[distr])) # 根据概率p0选出rank1个顶点 support_batch = sparse_to_tuple(normADJ_batch[:, q1].dot( sp.diags(1.0 / (p0[q1] * samplesize)))) if len(support_batch[1]) == 0: continue features_inputs = sparse_to_tuple( csr_matrix(dense_AXfeatures_train[q1, :])) """print(support_batch[2], features_inputs[2]) >>> (200, 50) (50, 1433)""" # support_batch used at 2nd layer params = construct_params( features_inputs, support_batch) with tf.GradientTape() as tape: logits = model.forward(params) loss = model._loss(logits, y_train_batch) model._update(tape, loss) train_logits = model.forward(construct_params( tuple_AXfeatures_train, sparse_to_tuple(csr_normADJ_train))) train_acc = accuracy(train_logits, y_train) val_logits = model.forward(construct_params( tuple_AXfeatures_val, sparse_to_tuple(csr_normADJ_val))) val_acc = accuracy(val_logits, y_val) test_logits = model.forward(construct_params( tuple_AXfeatures_test, sparse_to_tuple(csr_normADJ_test))) test_acc = accuracy(test_logits, y_test) view_bar('epoch', epoch+1, epochs, loss, train_acc, val_acc, test_acc, time.time()-t)
本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:FastGCN论文总结及实现(Tensorflow2.0) - Python技术站