def make_embedding(CV, MODEL, DATA, EMBED):
DATA_FOLD = DATA + f"/FOLD-{CV}"
if not os.path.exists(EMBED):
os.mkdir(EMBED)
graph, features, labels = load_dataset(DATA, DATA_FOLD)
fltr = GraphConv.preprocess(graph).astype('f4')
fltr = ops.sp_matrix_to_sp_tensor(fltr)
X_in = Input((features.shape[1], ))
fltr_in = Input((features.shape[0], ), sparse=True)
X_1 = GraphConv(512, 'relu', True,
kernel_regularizer=l2(5e-4))([X_in, fltr_in])
X_1 = Dropout(0.5)(X_1)
X_2 = GraphConv(256, 'relu', True,
kernel_regularizer=l2(5e-4))([X_1, fltr_in])
X_2 = Dropout(0.5)(X_2)
X_3 = GraphConv(128, 'relu', True,
kernel_regularizer=l2(5e-4))([X_2, fltr_in])
X_3 = Dropout(0.5)(X_3)
X_4 = GraphConv(64, 'linear', True,
kernel_regularizer=l2(5e-4))([X_3, fltr_in])
X_5 = Dense(labels.shape[1], use_bias=True)(X_4)
loaded_model = load_model(f"{MODEL}")
model_without_task = Model(inputs=[X_in, fltr_in], outputs=X_4)
model_without_task.set_weights(loaded_model.get_weights()[:8])
final_node_representations = model_without_task([features, fltr],
training=False)
save_embedding(final_node_representations, EMBED, DATA_FOLD, CV)
def load_folded_dataset(self, path):
with open(path + "/graph.json", 'r') as f:
graph_json = json.load(f)
graph = nx.json_graph.node_link_graph(graph_json)
adjacency_mat = nx.adjacency_matrix(graph)
fltr = GraphConv.preprocess(adjacency_mat).astype('f4')
self.fltr = ops.sp_matrix_to_sp_tensor(fltr)
self.features = np.load(path + "/feats.npy")
self.train_mask = np.load(path + "/train_mask.npy")
self.valid_mask = np.load(path + "/valid_mask.npy")
self.train_labels = GCN.labels[self.train_mask]
self.valid_labels = GCN.labels[self.valid_mask]
c2v_k=50,
t2v_k=100,
maxlen=maxlen)
for inum in range(2, 3):
graph_dict, \
tagDict_train, tagDict_dev, tagDict_test, \
word_vob, word_id2word, word_W, w2v_k, \
char_vob, char_id2char, char_W, c2v_k, \
target_vob, target_id2word, \
posi_W, posi_k, type_W, type_k, \
max_s, max_posi, max_c = pickle.load(open(datafile, 'rb'))
A = nx.adjacency_matrix(nx.from_dict_of_lists(graph_dict))
fltr = GraphConv.preprocess(A).astype('f4')
print('fltr.toarray.shape ... ', fltr.toarray().shape)
nn_model = SelectModel(modelname,
node_count=len(graph_dict),
wordvocabsize=len(word_vob),
tagvocabsize=len(target_vob),
posivocabsize=max_posi + 1,
charvocabsize=len(char_vob),
word_W=word_W,
posi_W=posi_W,
tag_W=type_W,
char_W=char_W,
input_sent_lenth=max_s,
w2v_k=w2v_k,
posi2v_k=max_posi + 1,
os.mkdir(models)
if not os.path.exists(MODEL):
os.mkdir(MODEL)
DATA = f"./Data/results/v3/FOLD-{1}"
logging.basicConfig(filename=f"{MODEL}/train.log", level=logging.DEBUG)
logger = logging.getLogger()
logger.info(f"Path for Dataset = {DATA}")
logger.info(f"Path for Models = {MODEL}")
labels = np.load("./Data/results/v3/labels.npy")
with open(DATA + "/graph.json", 'r') as f:
graph_json = json.load(f)
graph = nx.json_graph.node_link_graph(graph_json)
adjacency_mat = nx.adjacency_matrix(graph)
fltr = GraphConv.preprocess(adjacency_mat).astype('f4')
fltr = ops.sp_matrix_to_sp_tensor(fltr)
features = np.load(DATA + "/feats.npy")
train_mask = np.load(DATA + "/train_mask.npy")
valid_mask = np.load(DATA + "/valid_mask.npy")
train_labels = labels[train_mask]
valid_labels = labels[valid_mask]
strategy = tf.distribute.experimental.ParameterServerStrategy(
cluster_resolver)
with strategy.scope():
def create_model(features_shape, labels_shape):
X_in = Input((features_shape[1], ))
fltr_in = Input((features_shape[0], ), sparse=True)
from spektral.layers import GraphConv
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dropout
# %%
X_in = Input(shape=(F, ))
A_in = Input((N, ), sparse=True)
X_1 = GraphConv(16, "relu")([X_in, A_in])
X_1 = Dropout(0.5)(X_1)
X_2 = GraphConv(n_classes, "softmax")([X_1, A_in])
model = Model(inputs=[X_in, A_in], outputs=X_2)
# %%
A = GraphConv.preprocess(A).astype("f4")
# %%
model.compile(optimizer="adam",
loss="categorical_crossentropy",
weighted_metrics=["acc"])
model.summary()
# %%
# Prepare data
X = X.toarray()
A = A.astype("f4")
validation_data = ([X, A], y, val_mask)
# Train model
model.fit(
# Parameters
l2_reg = 5e-4 # Regularization rate for l2
learning_rate = 1e-3 # Learning rate for SGD
batch_size = 32 # Batch size
epochs = 1000 # Number of training epochs
es_patience = 10 # Patience fot early stopping
# Load data
X_train, y_train, X_val, y_val, X_test, y_test, A = mnist.load_data()
X_train, X_val, X_test = X_train[..., None], X_val[..., None], X_test[..., None]
N = X_train.shape[-2] # Number of nodes in the graphs
F = X_train.shape[-1] # Node features dimensionality
n_out = 10 # Dimension of the target
fltr = GraphConv.preprocess(A)
# Model definition
X_in = Input(shape=(N, F))
# Pass A as a fixed tensor, otherwise Keras will complain about inputs of
# different rank.
A_in = Input(tensor=sp_matrix_to_sp_tensor(fltr))
graph_conv = GraphConv(32,
activation='elu',
kernel_regularizer=l2(l2_reg))([X_in, A_in])
graph_conv = GraphConv(32,
activation='elu',
kernel_regularizer=l2(l2_reg))([graph_conv, A_in])
flatten = Flatten()(graph_conv)
fc = Dense(512, activation='relu')(flatten)
