from os.path import expanduser
import gzip
import pickle
import pathlib
import tensorflow as tf;
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
print('tf version:', tf.__version__)
assert tf.__version__.startswith('2.')
if __name__ == '__main__':
filedir = os.path.dirname(__file__)
model_dir = f'{filedir}/../trained_models/{args.problem}/TRIG-GCN'
model = GCN( output_dim=2)
model.load_weights(f'{model_dir}/model.ckpt')
####### data #######
for data_dir in ['test_small', 'test_medium']:
data_path = f'{filedir}/../datasets/{args.problem}/{data_dir}'
data_files = list(pathlib.Path(data_path).glob('sample_*.pkl'))
data_files = [str(data_file) for data_file in data_files][:100]
os.makedirs(f'{filedir}/../ret_model', exist_ok=True)
logfile = f'{filedir}/../ret_model/{args.problem}_{data_dir}_TRIG_GCN.txt'
nsamples = len(data_files)
log(f'test dataset: <{data_path}>, number of instances: {nsamples}', logfile)
log(f'log write to: <{logfile}>', logfile)
t1 = time.time()
ct=0
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():
adj, features, all_labels, train, val, test = load_data(
args.dataset, task_type=args.task_type)
whole_batch = args.whole_batch
print('adj:', adj.shape)
print('features:', features.shape)
MAX_NBS = params['max_degree']
# padding adj to N*K, where K is the number of nbs
adj_list = get_adj_list(adj, MAX_NBS)
adj_mask = adj_list + 1
adj_mask[adj_mask > 0] = 1
features = preprocess_features(
features) # [49216, 2], [49216], [2708, 1433]
# add a row
fea = np.asarray(features)
fea = np.insert(fea, -1, 0, axis=0)
fea.reshape((features.shape[0] + 1, features.shape[-1]))
features = fea
dl = data_loader(features, adj_list, train, val, test)
tf.keras.backend.clear_session()
model = GCN(input_dim=features.shape[1], output_dim=all_labels.shape[1], num_features_nonzero=features[1].shape, \
feature=features, label=all_labels, adj_list=adj_list, adj_mask=adj_mask) # [1433]
optimizer = optimizers.Adam(lr=params['learning_rate'])
persist = 0
best_val_acc = 0
for epoch in range(args.epochs):
if whole_batch:
with tf.GradientTape() as tape:
train_loss, train_acc = model(train, training=True)
grads = tape.gradient(train_loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
else:
while not dl.train_end():
batch = dl.get_train_batch(
batch_size=params['train_batch_size'])
with tf.GradientTape() as tape:
train_loss, train_acc = model(batch, training=True)
grads = tape.gradient(train_loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads,
model.trainable_variables))
val_loss = 0
val_acc = 0
if whole_batch:
val_loss, val_acc = model(val)
else:
while not dl.val_end():
batch = dl.get_val_batch(batch_size=args.val_batch_size)
loss, acc = model(batch, training=False)
val_loss += loss * len(batch)
val_acc += acc * len(batch)
val_acc /= len(val)
val_loss /= len(val)
if val_acc > best_val_acc:
best_val_acc = val_acc
persist = 0
model.save_weights(check_file)
else:
persist += 1
if persist > args.early_stopping:
break
if epoch % 10 == 0:
print(epoch, float(train_loss), float(train_acc), '\tval:',
float(val_acc))
print('train done')
model.load_weights(check_file)
print('read checkpoint done')
test_loss = 0
test_acc = 0
if whole_batch:
test_loss, test_acc = model(test)
else:
while not dl.test_end():
batch = dl.get_test_batch(batch_size=args.test_batch_size)
loss, acc = model(batch, training=False)
test_loss += loss * len(batch)
test_acc += acc * len(batch)
test_acc /= len(test)
test_loss /= len(test)
print('final results', test_acc.numpy())
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')
