用matalb、python画聚类结果图

---

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)