def call(self, x):
g0 = scipy.sparse.csr_matrix(self.build_graph()).astype(np.float32)
graphs0 = []
for i in range(self.num_layers):
graphs0.append(g0)
L = [graph.laplacian(A, normalized=True) for A in graphs0]
gcn_out = []
for i in range(self.num_layers):
with tf.variable_scope('gcn{}'.format(i + 1)):
with tf.name_scope('filter'):
old = x
x = self.my_gcn(x, L[i], str(i))
with tf.name_scope('bias_relu'):
x = self.brelu(x)
with tf.name_scope('pooling'):
x = MaxPooling1D(pool_size=1, padding='same')(x)
att = activations.softmax(x - old)
if i > 0: x = tf.multiply(x, att)
gcn_out.append(x)
#x = tf.multiply(x,att)
x = tf.concat(gcn_out, -1)
# print('out_x',x.get_shape())
x = K.dot(x, self.w_layers)
# print('dot_x',x.get_shape())
x = K.squeeze(x, 2)
return x
def get_laplacians(adj_list):
laplacians_list = []
for adj_item in adj_list:
laplacian = graph.laplacian(adj_item, normalized=True)
laplacian = laplacian_to_sparse(laplacian)
laplacians_list.append(laplacian)
return laplacians_list
def build_graph(cls, args):
number_edges = args.number_edges
metric = args.metric
normalized_laplacian = args.normalized_laplacian
coarsening_levels = args.coarsening_levels
def grid_graph(m, corners=False):
z = graph.grid(m)
# compute pairwise distance
dist, idx = graph.distance_sklearn_metrics(z, k=number_edges, metric=metric)
A = graph.adjacency(dist, idx) # build adjacent matrix
# Connections are only vertical or horizontal on the grid.
# Corner vertices are connected to 2 neightbors only.
if corners:
A = A.toarray()
A[A < A.max()/1.5] = 0
A = scipy.sparse.csr_matrix(A)
print('{} edges'.format(A.nnz))
print("{} > {} edges".format(A.nnz//2, number_edges*m**2//2))
return A
g = grid_graph(28, corners=False)
g = graph.replace_random_edges(g, 0)
graphs, perm = coarsening.coarsen(g, levels=coarsening_levels, self_connections=False)
laplacians = [graph.laplacian(g, normalized=True) for g in graphs]
cls.perm = perm
cls.graphs = graphs
cls.laplacians = laplacians
def build_laplacian(k):
fullgraph = pickle.load(open(r"C:\Users\veronica\Desktop\study\Deep Learning\Project\full_interactions_graph", 'rb'))[0:k, 0:k]
A = csr_matrix(fullgraph).astype(np.float32)
graphs, perm = coarsening.coarsen(A, levels=3, self_connections=False)
L = [graph.laplacian(A, normalized=True) for A in graphs]
pickle.dump(L, open("L"+str(k), 'wb'))
pickle.dump(perm, open("prem"+str(k), 'wb'))
return L, perm
def cal_lap(graph):
g0 = sparse.csr_matrix(utils.build_graph(graph)).astype(np.float32)
print('graph_size:', g0.shape)
graphs0 = []
for i in range(3):
graphs0.append(g0)
L0 = [graph.laplacian(A, normalized=True) for A in graphs0]
L1 = L0
def __init__(self, adj, classes_num, args):
super(FineGrainedGCNN, self).__init__()
self.batch_size = args.batch_size
self.filter_size = args.filter_size
self.pooling_size = args.pooling_size
self.poly_degree = args.poly_degree
self.adjs_1 = [adj.toarray() for j in range(self.batch_size)]
self.classes_num = classes_num
laplacian = graph.laplacian(adj, normalized=True)
laplacian = laplacian_to_sparse(laplacian)
laplacians_1 = [laplacian for i in range(self.batch_size)]
self.feature_num = 5
self.laplacians_gn = None
# --- Gating Notwork
self.gc = ChebshevGCNN(
in_channels=self.poly_degree[0], # 25
out_channels=self.filter_size[0], # 32
poly_degree=self.poly_degree[0], # 25
pooling_size=self.pooling_size[0],
laplacians=laplacians_1)
self.fc = nn.Linear(in_features=62 * self.filter_size[0] *
self.feature_num,
out_features=classes_num)
# --- Expert 1
self.gc_expert_1 = ChebshevGCNN(
in_channels=self.poly_degree[0], # 25
out_channels=self.filter_size[0], # 32
poly_degree=self.poly_degree[0], # 25
pooling_size=self.pooling_size[0],
laplacians=laplacians_1)
self.fc_expert_1 = nn.Linear(in_features=62 * self.filter_size[0] *
self.feature_num,
out_features=self.classes_num)
# --- Expert 2
self.gc_expert_2 = ChebshevGCNN(
in_channels=self.poly_degree[0], # 25
out_channels=self.filter_size[0], # 32
poly_degree=self.poly_degree[0], # 25
pooling_size=self.pooling_size[0],
laplacians=laplacians_1)
self.fc_expert_2 = nn.Linear(in_features=62 * self.filter_size[0] *
self.feature_num,
out_features=self.classes_num).to(DEVICE)
# --- Expert 3
self.gc_expert_3 = ChebshevGCNN(
in_channels=self.poly_degree[0], # 25
out_channels=self.filter_size[0], # 32
poly_degree=self.poly_degree[0], # 25
pooling_size=self.pooling_size[0],
laplacians=laplacians_1)
self.fc_expert_3 = nn.Linear(in_features=62 * self.filter_size[0] *
self.feature_num,
out_features=self.classes_num).to(DEVICE)
def call(self, x):
g0 = scipy.sparse.csr_matrix(self.build_graph()).astype(np.float32)
graphs0 = []
for i in range(3):
graphs0.append(g0)
L = [graph.laplacian(A, normalized=True) for A in graphs0]
for i in range(2):
with tf.variable_scope('gcn{}'.format(i + 1)):
with tf.name_scope('filter'):
x = self.my_gcn(x, L[i], str(i))
with tf.name_scope('bias_relu'):
x = self.brelu(x)
with tf.name_scope('pooling'):
x = MaxPooling1D(pool_size=1, padding='same')(x)
x = K.squeeze(x, 2)
return x
def init_sampling(refer_mesh, data_dir, dataname, ds_factors=(4, 4, 4, 4)):
# Sampling factor of the mesh at each stage of sampling
# Generates adjecency matrices A, downsampling matrices D, and upsamling matrices U by sampling
# the mesh 4 times. Each time the mesh is sampled by a factor of 4
adj_path = os.path.join(data_dir, 'adjacency')
ds_path = os.path.join(data_dir, 'downsamp_trans')
us_path = os.path.join(data_dir, 'upsamp_trans')
lap_path = os.path.join(data_dir, 'laplacians')
if not os.path.isfile(lap_path + '0.npz'):
logger = logging.getLogger('x')
logger.info('Computing Sampling Parameters')
adjacencies, downsamp_trans, upsamp_trans = mesh_sampling.generate_transform_matrices(
dataname, refer_mesh['vertices'], refer_mesh['faces'], ds_factors)
adjacencies = [x.astype('float32') for x in adjacencies]
downsamp_trans = [x.astype('float32') for x in downsamp_trans]
upsamp_trans = [x.astype('float32') for x in upsamp_trans]
laplacians = [graph.laplacian(a, normalized=True) for a in adjacencies]
if not os.path.exists(data_dir):
os.makedirs(data_dir)
for i, a in enumerate(adjacencies):
sp.save_npz(adj_path + '{}.npz'.format(i), a)
for i, d in enumerate(downsamp_trans):
sp.save_npz(ds_path + '{}.npz'.format(i), d)
for i, u in enumerate(upsamp_trans):
sp.save_npz(us_path + '{}.npz'.format(i), u)
for i, l in enumerate(laplacians):
sp.save_npz(lap_path + '{}.npz'.format(i), l)
else:
adjacencies = []
downsamp_trans = []
upsamp_trans = []
laplacians = []
for a in sorted(glob('{}*.npz'.format(adj_path))):
adjacencies.append(sp.load_npz(a))
for d in sorted(glob('{}*.npz'.format(ds_path))):
downsamp_trans.append(sp.load_npz(d))
for u in sorted(glob('{}*.npz'.format(us_path))):
upsamp_trans.append(sp.load_npz(u))
for l in sorted(glob('{}*.npz'.format(lap_path))):
laplacians.append(sp.load_npz(l))
pool_size = [x.shape[0] for x in adjacencies]
return laplacians, downsamp_trans, upsamp_trans, pool_size
def build_graph(cls, args):
number_edges = args.number_edges
metric = args.metric
normalized_laplacian = args.normalized_laplacian
coarsening_levels = args.coarsening_levels
data_dir = 'data/20news'
embed_path = os.path.join(data_dir, 'embeddings.npy')
graph_data = np.load(embed_path).astype(np.float32)
dist, idx = graph.distance_sklearn_metrics(graph_data,
k=number_edges,
metric=metric)
adj_matrix = graph.adjacency(dist, idx)
print("{} > {} edges".format(adj_matrix.nnz // 2,
number_edges * graph_data.shape[0] // 2))
adj_matrix = graph.replace_random_edges(adj_matrix, 0)
graphs, perm = coarsening.coarsen(adj_matrix,
levels=coarsening_levels,
self_connections=False)
laplacians = [
graph.laplacian(g, normalized=normalized_laplacian) for g in graphs
]
cls.perm = perm
cls.graphs = graphs
cls.laplacians = laplacians
t_start = time.process_time()
tile_number = int((np.log2(
(FLAGS.vertex_number - 2) / 10)) / 2) #2**(2*tile_num)*10+2=vertex_number#
graphs_adjacency = []
z_xyz = []
vertex_theta = []
for m in range(tile_number, tile_number - FLAGS.coarsening_levels - 1, -1):
z, z_theta, A = grid_graph(
m, 1,
corners=False) #m is the tile_number,r is the radius of the sphere
z_xyz.append(z)
vertex_theta.append(z_theta)
graphs_adjacency.append(A)
L = [graph.laplacian(A, normalized=True) for A in graphs_adjacency]
print(len(L))
index = []
for m in range(FLAGS.coarsening_levels):
temp = []
for j in z_xyz[m + 1]:
temp.append(z_xyz[m].index(j))
index.append(temp)
print('the shape of index', len(index), len(index[0]), len(index[1]))
project_data_path = 'data/mnist_2562_TT' # for mnist
#project_data_path = 'data/cifar10_2562_FFT' # for cifar10
#project_data_path = '/mnt/data/modelnet40_40962_TTT' # for modelnet40
if not os.path.exists(project_data_path):
site_train[i] = 0
print("Training samples shape")
print(X_train.shape)
# Get the graph structure
dist, idx = graph.distance_scipy_spatial(coords, k=10, metric='euclidean')
A = graph.adjacency(dist, idx).astype(np.float32)
graphs = []
for i in range(3):
graphs.append(A)
# Calculate Laplacians
L = [graph.laplacian(A, normalized=True) for A in graphs]
# Number of nodes in graph and features
print("Number of controls in the dataset: ")
print(y.sum())
# Prepare training testing and validation sets
X_test, y_test, site_test = prepare_pairs(X, y, site, test_idx)
n, m, f, _ = X_train.shape
# Graph Conv-net
features = 64
K = 3
params = dict()
params['num_epochs'] = 80
def main():
createFolder('Result')
config_file = sys.argv[1]
with open(config_file, 'r') as f:
config = yaml.load(f)
PPI_data = config["PPI_data"]
Response_data = config["Response_data"]
Gene_data = config["Gene_data"]
n_fold = config["n_fold"]
test_size = config["test_size"]
num_epochs = config["num_epochs"]
batch_size = config["batch_size"]
brelu = config["brelu"]
pool = config["pool"]
regularization = config["regularization"]
dropout = config["dropout"]
learning_rate = config["learning_rate"]
decay_rate = config["decay_rate"]
momentum = config["momentum"]
Name = config["Name"]
F = config["F"]
K = config["K"]
p = config["p"]
M = config["M"]
data_PPI = pd.read_csv(PPI_data)
data_PPI.drop(['Unnamed: 0'], axis='columns', inplace=True)
data_IC50 = pd.read_csv(Response_data)
data_IC50.drop(['Unnamed: 0'], axis='columns', inplace=True)
data_Gene = pd.read_csv(Gene_data)
data_Gene.drop(['Unnamed: 0'], axis='columns', inplace=True)
data_Gene = np.array(data_Gene)
df = np.array(data_PPI)
A = coo_matrix(df, dtype=np.float32)
print(A.nnz)
graphs, perm = coarsening.coarsen(A, levels=6, self_connections=False)
L = [graph.laplacian(A, normalized=True) for A in graphs]
graph.plot_spectrum(L)
n_fold = n_fold
PCC = []
SPC = []
RMSE = []
X_train, X_test, Y_train, Y_test = train_test_split(data_Gene,
data_IC50,
test_size=test_size,
shuffle=True,
random_state=20)
for cv in range(n_fold):
Y_pred = np.zeros([Y_test.shape[0], Y_test.shape[1]])
Y_test = np.zeros([Y_test.shape[0], Y_test.shape[1]])
j = 0
for i in range(Y.test.shape[1]):
data1 = data_IC50.iloc[:, i]
data1 = np.array(data1)
data_minmax = data1[~np.isnan(data1)]
min = data_minmax.min()
max = data_minmax.max()
data1 = (data1 - min) / (max - min)
train_data_split, test_data_split, train_labels_split, test_labels_split = train_test_split(
data_Gene,
data1,
test_size=test_size,
shuffle=True,
random_state=20)
train_data = np.array(
train_data_split[~np.isnan(train_labels_split)]).astype(
np.float32)
list_train, list_val = Validation(n_fold, train_data,
train_labels_split)
train_data_V = train_data[list_train[cv]]
val_data = train_data[list_val[cv]]
test_data = np.array(test_data_split[:]).astype(np.float32)
train_labels = np.array(
train_labels_split[~np.isnan(train_labels_split)]).astype(
np.float32)
train_labels_V = train_labels[list_train[cv]]
val_labels = train_labels[list_val[cv]]
test_labels = np.array(test_labels_split[:]).astype(np.float32)
train_data_V = coarsening.perm_data(train_data_V, perm)
val_data = coarsening.perm_data(val_data, perm)
test_data = coarsening.perm_data(test_data, perm)
common = {}
common['num_epochs'] = num_epochs
common['batch_size'] = batch_size
common['decay_steps'] = train_data.shape[0] / common['batch_size']
common['eval_frequency'] = 10 * common['num_epochs']
common['brelu'] = brelu
common['pool'] = pool
common['regularization'] = regularization
common['dropout'] = dropout
common['learning_rate'] = learning_rate
common['decay_rate'] = decay_rate
common['momentum'] = momentum
common['F'] = F
common['K'] = K
common['p'] = p
common['M'] = M
if True:
name = Name
params = common.copy()
model = models.cgcnn(L, **params)
loss, t_step = model.fit(train_data_V, train_labels_V, val_data,
val_labels)
Y_pred[:, j] = model.predict(test_data)
Y_test[:, j] = test_labels
j = j + 1
np.savez(('Result/GraphCNN_CV_{}'.format(cv)),
Y_true=Y_test,
Y_pred=Y_pred)
def cross_validate_convNN(X,
y,
adjacency,
name_param,
value_param,
k,
num_levels=5):
split_index = split_test_train_for_cv(X.shape[0], k_fold=k)
graphs, perm = coarsening.coarsen(sp.csr_matrix(
adjacency.astype(np.float32)),
levels=num_levels,
self_connections=False)
accuracy = []
loss = []
for param_val in value_param:
accuracy_param = []
loss_param = []
for k_ in range(k):
test_samples = split_index[k_]
train_samples = split_index[~(
np.arange(split_index.shape[0]) == k_)].flatten()
X_train = X[train_samples]
X_test = X[test_samples]
y_train = y[train_samples]
y_test = y[test_samples]
X_train = coarsening.perm_data(X_train, perm)
X_test = coarsening.perm_data(X_test, perm)
n_train = X_train.shape[0]
L = [graph.laplacian(A, normalized=True) for A in graphs]
# Conv NN parameters
params = dict()
params['dir_name'] = 'demo'
params['num_epochs'] = 30
params['batch_size'] = 30
params['eval_frequency'] = 30
# Building blocks.
params['filter'] = 'chebyshev5'
params['brelu'] = 'b1relu'
params['pool'] = 'apool1'
# Number of classes.
C = y.max() + 1
assert C == np.unique(y).size
# Architecture.
params['F'] = [4, 8] # Number of graph convolutional filters.
params['K'] = [3, 3] # Polynomial orders.
params['p'] = [2, 8] # Pooling sizes.
params['M'] = [
256, C
] # Output dimensionality of fully connected layers.
# Optimization.
params['regularization'] = 4e-5
params['dropout'] = 1
params['learning_rate'] = 3e-3
params['decay_rate'] = 0.9
params['momentum'] = 0.8
params['decay_steps'] = n_train / params['batch_size']
params[name_param] = param_val
model = models.cgcnn(L, **params)
test_acc, train_loss, t_step = model.fit(X_train, y_train, X_test,
y_test)
accuracy_param.append([max(test_acc), np.mean(test_acc)])
loss_param.append([max(train_loss), np.mean(train_loss)])
print(np.array(accuracy_param))
pm = np.mean(np.array(accuracy_param), axis=0)
pl = np.mean(np.array(loss_param), axis=0)
print(
"IIIII Accuracy: %0.2f (max) %0.2f (mean) Loss: %0.2f (max) %0.2f (mean)"
% (pm[0], pm[1], pl[0], pl[1]))
accuracy.append(pm)
loss.append(pl)
return accuracy, loss
# Generates adjecency matrices A, downsampling matrices D, and upsamling matrices U by sampling
# the mesh 4 times. Each time the mesh is sampled by a factor of 4
M,A,D,U = mesh_sampling.generate_transform_matrices(facedata.reference_mesh, ds_factors)
A = map(lambda x:x.astype('float32'), A)
D = map(lambda x:x.astype('float32'), D)
U = map(lambda x:x.astype('float32'), U)
p = map(lambda x:x.shape[0], A)
X_train = facedata.vertices_train.astype('float32')
X_val = facedata.vertices_val.astype('float32')
X_test = facedata.vertices_test.astype('float32')
print("Computing Graph Laplacians ..")
L = [graph.laplacian(a, normalized=True) for a in A]
n_train = X_train.shape[0]
params = dict()
params['dir_name'] = args.name
params['num_epochs'] = args.num_epochs
params['batch_size'] = args.batch_size
params['eval_frequency'] = args.eval_frequency
# Building blocks.
params['filter'] = args.filter
params['brelu'] = 'b1relu'
params['pool'] = 'poolwT'
params['unpool'] = 'poolwT'
# Architecture.
def ABIDE_save(num_subjects, filename):
rs = 33
print("Random state is %d" % rs)
prng = np.random.RandomState(rs)
# Split into training, validation and testing sets
training_num = num_subjects
lines = int(1.2 * num_subjects)
# I am guessing this is to create a validation set within training data
# Used in the next moving step
# Get subject features
atlas = 'ho'
kind = 'correlation'
subject_IDs = abide_utils.get_ids(lines)
# Get all subject networks
networks = abide_utils.load_all_networks(subject_IDs,
kind,
atlas_name=atlas)
X = np.array(networks)
# with open('GCN_train.pkl', 'wb') as f: # Python 3: open(..., 'wb')
# pickle.dump(X, f, 2)
# f.close()
# Number of nodes
nodes = X.shape[1]
# Get ROI coordinates
coords = abide_utils.get_atlas_coords(atlas_name=atlas)
# Get subject labels
label_dict = abide_utils.get_subject_label(subject_IDs,
label_name='DX_GROUP')
y = np.array([int(label_dict[x]) - 1 for x in sorted(label_dict)])
# Get site ID
site = abide_utils.get_subject_label(subject_IDs, label_name='SITE_ID')
unq = np.unique(list(site.values())).tolist()
site = np.array([unq.index(site[x]) for x in sorted(site)])
# Choose site IDs to include in the analysis
site_mask = range(20)
X = X[np.in1d(site, site_mask)]
y = y[np.in1d(site, site_mask)]
site = site[np.in1d(site, site_mask)]
tr_idx, test_idx = split_data(site, 0.6)
# training_num = int(0.6 * X.shape[0])
prng.shuffle(test_idx)
subs_to_add = training_num - len(
tr_idx) # subjects that need to be moved from testing to training set
tr_idx.extend(test_idx[:subs_to_add])
test_idx = test_idx[subs_to_add:]
print("The test indices are the following: ")
print(test_idx)
all_combs = []
tr_mat = np.array(tr_idx).reshape([int(len(tr_idx) / 6), 6])
for i in range(3):
x1 = tr_mat[:, i * 2].flatten()
x2 = tr_mat[:, i * 2 + 1].flatten()
combs = np.transpose([np.tile(x1, len(x2)), np.repeat(x2, len(x1))])
all_combs.append(combs)
all_combs = np.vstack(all_combs)
# print(all_combs.shape)
n, m, f = X.shape
X_train = np.ones((all_combs.shape[0], m, f, 2), dtype=np.float32)
y_train = np.ones(all_combs.shape[0], dtype=np.int32)
site_train = np.ones(all_combs.shape[0], dtype=np.int32)
for i in range(all_combs.shape[0]):
X_train[i, :, :, 0] = X[all_combs[i, 0], :, :]
X_train[i, :, :, 1] = X[all_combs[i, 1], :, :]
if y[all_combs[i, 0]] != y[all_combs[i, 1]]:
y_train[i] = 0 # -1
if site[all_combs[i, 0]] != site[all_combs[i, 1]]:
site_train[i] = 0
print("Training samples shape")
print(X_train.shape)
# Get the graph structure
dist, idx = graph.distance_scipy_spatial(coords, k=10, metric='euclidean')
A = graph.adjacency(dist, idx).astype(np.float32)
graphs = []
for i in range(3):
graphs.append(A)
# Calculate Laplacians
L = [graph.laplacian(A, normalized=True) for A in graphs]
# Number of nodes in graph and features
print("Number of controls in the dataset: ")
print(y.sum())
# Prepare training testing and validation sets
X_test, y_test, site_test = prepare_pairs(X, y, site, test_idx)
# Saving training data for comparison with ann siamese
np.savez(filename,
'.npz',
name1=X_train,
name2=y_train,
name3=X_test,
name4=y_test,
name5=all_combs,
name6=site_train,
name7=site_test,
name8=tr_idx)
return None
if corners:
import scipy.sparse
A = A.toarray()
A[A < A.max()/1.5] = 0
A = scipy.sparse.csr_matrix(A)
print('{} edges'.format(A.nnz))
print("{} > {} edges".format(A.nnz//2, FLAGS.number_edges*m**2//2))
return A
t_start = time.process_time()
A = grid_graph(28, corners=False)
A = graph.replace_random_edges(A, 0)
#graphs, perm = coarsening.coarsen(A, levels=FLAGS.coarsening_levels, self_connections=False)
#L = [graph.laplacian(A, normalized=True) for A in graphs]
L = [graph.laplacian(A, normalized=True)]
print('Execution time: {:.2f}s'.format(time.process_time() - t_start))
graph.plot_spectrum(L)
del A
from tensorflow.examples.tutorials.mnist import input_data
print(FLAGS.dir_data)
mnist = input_data.read_data_sets(FLAGS.dir_data, one_hot=False)
train_data = mnist.train.images.astype(np.float32)
val_data = mnist.validation.images.astype(np.float32)
test_data = mnist.test.images.astype(np.float32)
train_labels = mnist.train.labels
val_labels = mnist.validation.labels
test_labels = mnist.test.labels
y_val = y[n_train:, ...]
A = np.load('/Neutron9/joyneel.misra/npys/meanFC_d'+str(d)+'.npy');
A = A - np.min(A)
A = scipy.sparse.csr_matrix(A)
d = X.shape[1]
assert A.shape == (d, d)
print('d = |V| = {}, k|V| < |E| = {}'.format(d, A.nnz))
graphs, perm = coarsening.coarsen(A, levels=3, self_connections=False)
X_train = coarsening.perm_data(X_train, perm)
X_val = coarsening.perm_data(X_val, perm)
L = [graph.laplacian(A, normalized=True) for A in graphs]
L = [elem.astype(np.float32) for elem in L]
params = dict()
params['dir_name'] = 'demo'
params['num_epochs'] = 10
params['batch_size'] = 40
params['eval_frequency'] = 100
# Building blocks.
params['filter'] = 'chebyshev5'
params['brelu'] = 'b1relu'
params['pool'] = 'apool1'
# Number of attributes in target.
C = np.max(y)+1
def constructingGraph(inFIDDic,
data_type,
mean_geometry=0,
std_geometry=1,
is_distance=True):
#inFiDDic {key,[label,pointlist]}
if len(inFIDDic) < 1: return None
vertices_Geometry, adjacencies, labels, inFIDs, process_count = [], [], [], [], 0
for k in inFIDDic:
[label, Node_coords, Node_features] = inFIDDic[k]
assert len(Node_coords) == len(Node_features)
subObject_size = len(Node_coords)
# # 1 get the label of this sample.
label = 1 if label == 3 else 0
# # 3 get the adjacency graph of the building group (one sample).
# # MST, Delaunay, K-NN
points = np.array(Node_coords)
adjacency = np.zeros((subObject_size, subObject_size))
tri = Delaunay(points[:, 0:2])
for i in range(0, tri.nsimplex):
if i > tri.neighbors[i, 2]:
adjacency[tri.vertices[i, 0], tri.vertices[i, 1]] = 1
adjacency[tri.vertices[i, 1], tri.vertices[i, 0]] = 1
if i > tri.neighbors[i, 0]:
adjacency[tri.vertices[i, 1], tri.vertices[i, 2]] = 1
adjacency[tri.vertices[i, 2], tri.vertices[i, 1]] = 1
if i > tri.neighbors[i, 1]:
adjacency[tri.vertices[i, 2], tri.vertices[i, 0]] = 1
adjacency[tri.vertices[i, 0], tri.vertices[i, 2]] = 1
adjacency = scipy.sparse.coo_matrix(adjacency,
shape=(subObject_size,
subObject_size))
# In order to make the calculation simpler, only the distance between the center points of the buildings is provided here.
# According to the author's experience, the closest distance of two building outlines coule be a better opition for this task.
distances = sklearn.metrics.pairwise.pairwise_distances(
points[:, 0:2], metric="euclidean", n_jobs=1)
if False:
# K-nearest neighbor graph.
# Distance matrix. is it necessary to be normalized?
idx = np.argsort(distances)[:, 1:1 + 1]
distances.sort()
distances = graph.adjacency(distances[:, 1:1 + 1], idx)
adjacency = scipy.sparse.coo_matrix(
np.ones((subObject_size, subObject_size)),
shape=(subObject_size, subObject_size)).multiply(distances)
# print(distances.toarray())# adjacency = adjacency.multiply(distances)
else:
adjacency = adjacency.multiply(distances)
if False:
# MST graph.
adjacency = scipy.sparse.csgraph.minimum_spanning_tree(
adjacency)
adjacency = scipy.sparse.csr_matrix(adjacency).toarray()
adjacency += adjacency.T - np.diag(adjacency.diagonal())
else:
# Delaunay graph.
adjacency = scipy.sparse.csr_matrix(adjacency).toarray()
#if is_distance:
# # Distance matrix. is it necessary to be normalized?
# distances = sklearn.metrics.pairwise.pairwise_distances(points[:,0:2], metric="euclidean", n_jobs=1)
# adjacency = adjacency.multiply(distances)
adjacency = scipy.sparse.csr_matrix(adjacency)
assert subObject_size == points.shape[0]
assert type(adjacency) is scipy.sparse.csr.csr_matrix
# # 4 collecting the sample: vertice_Geometry,vertice_Fourier,adjacency,label.
vertices_Geometry.append(Node_features)
adjacencies.append(adjacency)
labels.append(label)
inFIDs.append(k)
# preprocessing inputs.
pro_method = True # to control the m
if pro_method:
# standardizing
if data_type == 1:
# Calculate the mean and std of train dataset, they also will be used to validation and test dataset.
concatenate_Geometry = np.concatenate(vertices_Geometry, axis=0)
mean_geometry = concatenate_Geometry.mean(axis=0)
std_geometry = concatenate_Geometry.std(axis=0)
if data_type == 1:
file = r'C:\Users\wh\Desktop\gcnn_classification\lib\data\_used_new22.txt'
file = "./lib/data/_config_22.txt"
conc = np.vstack((mean_geometry, std_geometry))
np.savetxt(file, conc, fmt='%.18f')
if data_type == -1: # for the extra experiment.
# Import the mean and std of train dataset.
file = r'C:\Users\wh\Desktop\gcnn_classification\lib\data\_used_new22.txt'
file = "./lib/data/_config_22.txt"
conc = np.loadtxt(file)
mean_geometry, std_geometry = conc[0, :], conc[1, :]
mean_fourier, std_fourier = conc[0, :], conc[
1, :] # This two parameters are just for fun, do not matter.
print(
"\n========import the mean and std of train dataset from text file========\n"
)
#print(mean_geometry)
#print(std_geometry)
if True:
# # The efficiency can be improved by means of vectorization.s
for i in range(0, len(vertices_Geometry)):
vertices_shape = np.array((vertices_Geometry[i])).shape
vertices_Geometry[i] -= np.tile(
mean_geometry, vertices_shape[0]).reshape(vertices_shape)
vertices_Geometry[i] /= np.tile(
std_geometry, vertices_shape[0]).reshape(vertices_shape)
# vertices_shape=np.array((vertices_Fourier[i])).shape
# vertices_Fourier[i] -= np.tile(mean_fourier,vertices_shape[0]).reshape(vertices_shape)
# vertices_Fourier[i] /= np.tile(std_fourier,vertices_shape[0]).reshape(vertices_shape)
else:
# normalizing, it is not working very well.
if data_type == 1:
# Calculate the mean and std of train dataset, they also will be used to validation and test dataset.
concatenate_Geometry = np.concatenate(vertices_Geometry, axis=0)
mean_geometry = concatenate_Geometry.min(axis=0)
std_geometry = concatenate_Geometry.max(axis=0)
file = r'C:\Users\wh\Desktop\gcnn_classification\lib\data\_used2.txt'
file = "./data/_config_ex.txt"
conc = np.vstack((mean_geometry, std_geometry))
np.savetxt(file, conc, fmt='%.18f')
if not pro_method:
# # The efficiency can be improved by means of vectorization.s
for i in range(0, len(vertices_Geometry)):
vertices_shape = np.array((vertices_Geometry[i])).shape
vertices_Geometry[i] = (vertices_Geometry[i] - np.tile(
mean_geometry, vertices_shape[0]).reshape(vertices_shape)
) / (std_geometry - mean_geometry)
# padding.
# the max number of vertices in a group (sample).
maxnum_vertices = 128 #max([len(vertices_Geometry[i]) for i in range(0,len(vertices_Geometry))])
graph_vertices_geo, graph_adjacencies = [], []
assert len(vertices_Geometry) == len(adjacencies) == len(labels)
#print(len(vertices_Geometry))
#print(len(vertices_Geometry[i]))
#print(np.pad(vertices_Geometry[i], ((0, maxnum_vertices-len(vertices_Geometry[i])),(0,0)), 'constant', constant_values=(0)).shape)
#exit()
for i in range(0, len(vertices_Geometry)):
graph_vertices_geo.append(
np.pad(vertices_Geometry[i],
((0, maxnum_vertices - len(vertices_Geometry[i])), (0, 0)),
'constant',
constant_values=(0)))
graph_adjacencies.append(
np.pad(adjacencies[i].toarray(),
((0, maxnum_vertices - adjacencies[i].shape[0]),
(0, maxnum_vertices - adjacencies[i].shape[0])),
'constant',
constant_values=(0)))
# collecting.
graph_vertices_geo = np.stack(graph_vertices_geo, axis=0).astype(
np.float32) #NSample x NVertices x NFeature
graph_adjacencies = np.stack(graph_adjacencies, axis=0).astype(
np.float32) #NSample x NVertices x NVertices
graph_labels = np.array(labels).astype(np.int64) #NSample x 1
graph_inFIDs = np.array(inFIDs).astype(np.int64) #NSample x 1
graph_size = graph_labels.shape[0] #NSample
graph_Laplacian = np.stack([
graph.laplacian(
scipy.sparse.csr_matrix(A), normalized=True, rescaled=True)
for A in graph_adjacencies
],
axis=0)
return [
graph_vertices_geo, graph_Laplacian, graph_labels, graph_inFIDs,
graph_size, mean_geometry, std_geometry
]
# load_data('gz1124i.json', [0.6, 0.2, 0.2])
M, A, D, U = mesh_sampling.generate_transform_matrices(facedata.reference_mesh,
ds_factors)
#A = list(map(lambda x:x.astype('float32'), A))
D = list(map(lambda x: x.astype('float32'), D))
U = list(map(lambda x: x.astype('float32'), U))
#p = list(map(lambda x:x.shape[0], A))
p = list(map(lambda x: x.v.shape[0], A))
X_train = facedata.vertices_train.astype('float32')
X_val = facedata.vertices_val.astype('float32')
X_test = facedata.vertices_test.astype('float32')
print("Computing Graph Laplacians ..")
L = [graph.laplacian(a, mode='cotan', normalized=True) for a in A]
L = list(map(lambda x: x.astype('float32'), L))
n_train = X_train.shape[0]
params = dict()
params['dir_name'] = args.name
params['num_epochs'] = args.num_epochs
params['batch_size'] = args.batch_size
params['eval_frequency'] = args.eval_frequency
# Building blocks.
params['filter'] = args.filter
params['brelu'] = 'b1relu'
params['pool'] = 'poolwT'
params['unpool'] = 'poolwT'
# Architecture.
def gcn_run(fname, train_num, batch_size):
rs = 222
print("Random state is %d" % rs)
prng = np.random.RandomState(rs)
np.random.seed(seed=222)
data = np.load(fname + '.npz')
X_train = np.array(data['name1'], dtype=np.float32)
y_train = np.array(data['name2'], dtype=np.float32)
X_test = np.array(data['name3'], dtype=np.float32)
y_test = np.array(data['name4'], dtype=np.float32)
all_combs = np.array(data['name5'], dtype=np.float32)
site_train = np.array(data['name6'], dtype=np.float32)
site_test = np.array(data['name7'], dtype=np.float32)
tr_idx = np.array(data['name8'], dtype=np.float32)
dist, idx = graph.distance_scipy_spatial(coords, k=10, metric='euclidean')
A = graph.adjacency(dist, idx).astype(np.float32)
graphs = []
for i in range(3):
graphs.append(A)
# Calculate Laplacians
L = [graph.laplacian(A, normalized=True) for A in graphs]
n, m, f, _ = X_train.shape
# Graph Conv-net
features = 64
K = 3
params = dict()
params['num_epochs'] = train_num
params['batch_size'] = batch_size
# params['eval_frequency'] = X_train.shape[0] / (params['batch_size'] * 2)
params['eval_frequency'] = 1
# Building blocks.
params['filter'] = 'chebyshev5'
params['brelu'] = 'b2relu'
params['pool'] = 'apool1'
# Architecture.
params['F'] = [features,
features] # Number of graph convolutional filters.
params['K'] = [K, K] # Polynomial orders.
params['p'] = [1, 1] # Pooling sizes.
params['M'] = [1] # Output dimensionality of fully cofeannected layers.
params['input_features'] = f
params['lamda'] = 0.35
params['mu'] = 0.6
# Optimization.
params['regularization'] = 5e-3
params['dropout'] = 0.8
params['learning_rate'] = 1e-2
params['decay_rate'] = 0.95
params['momentum'] = 0
params['decay_steps'] = X_train.shape[0] / params['batch_size']
params['dir_name'] = 'siamese_' + time.strftime("%Y_%m_%d_%H_%M") + '_feat' + str(params['F'][0]) + '_' + \
str(params['F'][1]) + '_K' + str(K) + '_state'
print(params)
# Run model
model = models_siamese.siamese_cgcnn_cor(L, **params)
print("Constructor finished")
accuracy, loss, scores_summary, tr_error, test_error = model.fit(
X_train, y_train, site_train, X_test, y_test, site_test)
#print('Time per step: {:.2f} ms'.format(t_step*1000))
# Save training
tr_res = model.evaluate(X_train, y_train, site_train)
# Evaluate test data
print("Test accuracy is:")
res = model.evaluate(X_test, y_test, site_test)
print(res[0])
return tr_error, test_error
