from models import GCN
from utils import *
import numpy as np
import scipy.io as sio
output_n = 64
sample, testdata, cateTrainTest, tradj, gfunc = load_cifar10(binary=True)
#sample, cateTrainTest, tradj, gfunc1, gfunc2 = load_imagenet(binary=True)
#traindata, cateTrainTest, tradj, gfunc1, gfunc2 = load_nuswide(binary=True)
#traindata, tradj = load_SIFT1M()
trgcn = GCN(sample, output_n, adj=tradj)
trgcn.build(lr=0.5, PCA=True)
for i in range(3):
for j in range(100):
loss = trgcn.train_fn(sample)
print 'epoch {0}/300 loss: {1}'.format(i*300+j+1, loss)
nz = trgcn.infer_fn(sample)
trgcn.loss_fn.update(nz)
B = trgcn.infer_fn(sample)
trgcn.save()
#trgcn.load('/mnt/disk1/ImageNett_model_%d' % output_n)
#np.save('%d' % output_n, np.sign(nz))
#after = trgcn.infer_fn(sample)
def main(dataset_name, yang_splits, dropout_rate, hidden_units,
training_epochs, learning_rate, l2_weight, patience, from_epoch,
baseline, data_seed, net_seed, model_path, verbose):
# reproducibility
np.random.seed(data_seed)
tf.random.set_seed(net_seed)
if yang_splits:
features, o_h_labels, A, mask_train, mask_val, mask_test = read_dataset(
dataset_name, yang_splits=True)
labels = np.array([np.argmax(l) for l in o_h_labels], dtype=np.int32)
else:
if verbose > 0: print("reading dataset")
features, neighbors, labels, o_h_labels, keys = read_dataset(
dataset_name)
if verbose > 0: print("shuffling dataset")
features, neighbors, labels, o_h_labels, keys = permute(
features, neighbors, labels, o_h_labels, keys)
if verbose > 0: print("obtaining masks")
mask_train, mask_val, mask_test = split(dataset_name, labels)
if verbose > 0: print("calculating adjacency matrix")
A = adjacency_matrix(neighbors)
num_classes = get_num_classes(dataset_name)
features = normalize_features(features)
y_train = np.multiply(o_h_labels,
np.broadcast_to(mask_train.T, o_h_labels.T.shape).T)
y_val = np.multiply(o_h_labels,
np.broadcast_to(mask_val.T, o_h_labels.T.shape).T)
y_test = np.multiply(o_h_labels,
np.broadcast_to(mask_test.T, o_h_labels.T.shape).T)
if verbose > 0: print("calculating renormalized matrix")
renormalized_matrix = renormalization_matrix(A)
num_nodes = A.shape[0]
num_features = len(features[0])
if verbose > 0: print("defining model")
model = GCN(renormalized_matrix, num_classes, dropout_rate, hidden_units)
model.compile(
loss=lambda y_true, y_pred: masked_loss(
y_true, y_pred, 'categorical_crossentropy') + l2_weight * tf.nn.
l2_loss(model.trainable_weights[0]), # regularize first layer only
optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
metrics=[masked_accuracy],
# run_eagerly=True
)
model.build(features.shape)
if verbose > 0: model.summary()
if verbose > 0: print("begin training")
callbacks = []
callbacks.append(
EarlyStoppingAvg(monitor='val_loss',
mode='min',
min_delta=0,
patience=patience,
from_epoch=from_epoch,
baseline=baseline,
restore_best_weights=True,
verbose=verbose))
callbacks.append(TensorBoard(log_dir='logs'))
if model_path is not None:
if not os.path.exists(model_path):
os.makedirs(model_path)
model_path = os.path.join(model_path, "ckpt")
callbacks.append(
ModelCheckpoint(monitor='val_loss',
mode='min',
filepath=model_path,
save_best_only=True,
save_weights_only=True,
verbose=verbose))
# input_shape: (num_nodes, num_features) -> output_shape: (num_nodes, num_classes)
model.fit(features,
y_train,
epochs=training_epochs,
batch_size=len(features),
shuffle=False,
validation_data=(features, y_val),
callbacks=callbacks,
verbose=verbose)
if model_path is not None:
model.load_weights(model_path)
file_writer = tf.summary.create_file_writer("./logs/results/")
file_writer.set_as_default()
# log best performances on train and val set
loss, accuracy = model.evaluate(features,
y_train,
batch_size=num_nodes,
verbose=0)
print("accuracy on training: " + str(accuracy))
tf.summary.scalar('bw_loss', data=loss, step=1)
tf.summary.scalar('bw_accuracy', data=accuracy, step=1)
v_loss, v_accuracy = model.evaluate(features,
y_val,
batch_size=num_nodes,
verbose=0)
print("accuracy on validation: " + str(v_accuracy))
tf.summary.scalar('bw_val_loss', data=v_loss, step=1)
tf.summary.scalar('bw_val_accuracy', data=v_accuracy, step=1)
tf.summary.scalar('bw_epoch', data=callbacks[0].stopped_epoch, step=1)
if verbose > 0: print("test the model on test set")
t_loss, t_accuracy = model.evaluate(features,
y_test,
batch_size=num_nodes,
verbose=0)
print("accuracy on test: " + str(t_accuracy))
tf.summary.scalar('bw_test_loss', data=t_loss, step=1)
tf.summary.scalar('bw_test_accuracy', data=t_accuracy, step=1)
def main(dataset_name, yang_splits, dropout_rate, hidden_units, l2_weight,
data_seed, model_path, verbose, tsne):
# reproducibility
np.random.seed(data_seed)
if yang_splits:
features, o_h_labels, A, mask_train, mask_val, mask_test = read_dataset(
dataset_name, yang_splits=True)
labels = np.array([np.argmax(l) for l in o_h_labels], dtype=np.int32)
else:
if verbose > 0: print("reading dataset")
features, neighbors, labels, o_h_labels, keys = read_dataset(
dataset_name)
if verbose > 0: print("shuffling dataset")
features, neighbors, labels, o_h_labels, keys = permute(
features, neighbors, labels, o_h_labels, keys)
if verbose > 0: print("obtaining masks")
mask_train, mask_val, mask_test = split(dataset_name, labels)
if verbose > 0: print("calculating adjacency matrix")
A = adjacency_matrix(neighbors)
num_classes = get_num_classes(dataset_name)
features = normalize_features(features)
y_train = np.multiply(o_h_labels,
np.broadcast_to(mask_train.T, o_h_labels.T.shape).T)
y_val = np.multiply(o_h_labels,
np.broadcast_to(mask_val.T, o_h_labels.T.shape).T)
y_test = np.multiply(o_h_labels,
np.broadcast_to(mask_test.T, o_h_labels.T.shape).T)
if verbose > 0: print("calculating renormalized matrix")
renormalized_matrix = renormalization_matrix(A)
num_nodes = A.shape[0]
num_features = len(features[0])
if verbose > 0: print("load model from checkpoint")
model = GCN(renormalized_matrix, num_classes, dropout_rate, hidden_units)
model.compile(
loss=lambda y_true, y_pred: masked_loss(
y_true, y_pred, 'categorical_crossentropy') + l2_weight * tf.nn.
l2_loss(model.trainable_weights[0]), # regularize first layer only
#optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
metrics=[masked_accuracy],
#run_eagerly=True
)
model.build(features.shape)
model.summary()
model.load_weights(os.path.join(model_path, "ckpt")).expect_partial()
if verbose > 0: print("test the model on test set")
loss, accuracy = model.evaluate(features,
y_test,
batch_size=num_nodes,
verbose=0)
print("accuracy on test: " + str(accuracy))
if tsne:
if verbose > 0: print("calculating t-SNE plot")
intermediate_layer_model = tf.keras.Sequential(
[model.layers[0], model.layers[1]])
intermediate_output = intermediate_layer_model.predict(
features, batch_size=num_nodes)
plot_tsne(intermediate_output[mask_test], labels[mask_test],
len(o_h_labels[0]), 'GCN')
