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')