def origin_model(): sensor_matrix = Input(shape=(num_sensors, num_sensors)) s_input1, extract_cnn1 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) #s_input2, extract_cnn2 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) #s_input3, extract_cnn3 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) #s_input4, extract_cnn4 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) #extract_cnn = Concatenate(axis=1)([extract_cnn1, extract_cnn2, extract_cnn3, extract_cnn4]) #extract_cnn = np.reshape(extract_cnn, (-1,)) G_1 = GraphConv(256, 'relu')([extract_cnn1, sensor_matrix]) G_2 = GraphConv(256, 'relu')([G_1, sensor_matrix]) #gnn_output = tf.split(G_2, num_sensors, 1) output1 = Dense(32, activation='relu')(Flatten()(G_2)) output1 = Dense(1, activation='linear', name='sensor_1')(output1) #output2 = Dense(32, activation='relu')(Flatten()(gnn_output[1])) #output2 = Dense(1, activation='linear', name='sensor_2')(output2) #output3 = Dense(32, activation='relu')(Flatten()(gnn_output[2])) #output3 = Dense(1, activation='linear', name='sensor_3')(output3) #output4 = Dense(32, activation='relu')(Flatten()(gnn_output[3])) #output4 = Dense(1, activation='linear', name='sensor_4')(output4) model = Model(inputs=[s_input1, sensor_matrix], outputs= [output1]) return model
def __init__(self, **kwargs): super().__init__(**kwargs) self.conv1 = GraphConv(32, activation='elu', kernel_regularizer=l2(l2_reg)) self.conv2 = GraphConv(32, activation='elu', kernel_regularizer=l2(l2_reg)) self.flatten = Flatten() self.fc1 = Dense(512, activation='relu') self.fc2 = Dense(n_out, activation='softmax')
def build_model(self, N, F, num_outputs): X_in = Input(shape=(N, F), name='X_in') A_in = Input(shape=(N, N), name='A_in') RL_indice = Input(shape=(N), name='rl_indice_in') ### Encoder x = Dense(32, activation='relu', name='encoder_1')(X_in) x = Dense(32, activation='relu', name='encoder_2')(x) ### Graphic convolution x = GraphConv(32, activation='relu', name='gcn1')([x, A_in]) # x = GraphConv(32, activation='relu',name='gcn2')([x, A_in]) ### Policy network x1 = Dense(32, activation='relu', name='policy_1')(x) x1 = GraphConv(32, activation='relu', name='gcn2')([x1, A_in]) x1 = Dense(32, activation='relu', name='policy_add')(x1) x2 = Dense(16, activation='relu', name='policy_2')(x1) ### Action and filter x3 = Dense(num_outputs, activation='linear', name='policy_3')(x2) filt = Reshape((N, 1), name='expend_dim')(RL_indice) qout = Multiply(name='filter')([x3, filt]) model = Model(inputs=[X_in, A_in, RL_indice], outputs=[qout]) # print(model.summary()) return model
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 robot_khop_model(): # input/output = num of sensors num_sensors = 9 input_shape = (84, 84 * 4, 3) sensor_matrix1 = Input(shape=(num_sensors + 1, num_sensors + 1)) sensor_matrix2 = Input(shape=(num_sensors + 1, num_sensors + 1)) #sensor_matrix3 = Input(shape=(num_sensors, num_sensors)) r_input = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input1 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input2 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input3 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input4 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input5 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input6 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input7 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input8 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input9 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_cnn = sensor_cnn(input_shape, repetitions=[2, 2, 2, 2]) robot_cnn = s_cnn(r_input) extract_cnn1 = s_cnn(s_input1) extract_cnn2 = s_cnn(s_input2) extract_cnn3 = s_cnn(s_input3) extract_cnn4 = s_cnn(s_input4) extract_cnn5 = s_cnn(s_input5) extract_cnn6 = s_cnn(s_input6) extract_cnn7 = s_cnn(s_input7) extract_cnn8 = s_cnn(s_input8) extract_cnn9 = s_cnn(s_input9) extract_cnn = Concatenate(axis=1)([ extract_cnn1, extract_cnn2, extract_cnn3, extract_cnn4, extract_cnn5, extract_cnn6, extract_cnn7, extract_cnn8, extract_cnn9, robot_cnn ]) #extract_cnn = np.reshape(extract_cnn, (-1,)) G_h1 = GraphConv(256, 'relu')([extract_cnn, sensor_matrix1]) G_h2 = GraphConv(256, 'relu')([extract_cnn, sensor_matrix2]) G_1 = Concatenate(axis=-1)([G_h1, G_h2]) G_2h1 = GraphConv(256, 'relu')([G_1, sensor_matrix1]) G_2h2 = GraphConv(256, 'relu')([G_1, sensor_matrix2]) G_2 = Concatenate(axis=-1)([G_2h1, G_2h2]) gnn_output = tf.split(G_2, num_sensors + 1, 1) r_output = Dense(64, activation='relu', name='policy_mlp')(Flatten()(gnn_output[-1])) output1 = Dense(2, activation='linear', name='robot_loss')(r_output) model = Model(inputs=[ s_input1, s_input2, s_input3, s_input4, s_input5, s_input6, s_input7, s_input8, s_input9, r_input, sensor_matrix1, sensor_matrix2 ], outputs=[output1]) return model
def __init__(self): super(MyModel, self).__init__() self.dp1 = Dropout(dropout) self.gcn1 = GraphConv(channels, activation='relu', kernel_regularizer=l2(l2_reg), use_bias=False) self.dp2 = Dropout(dropout) self.gcn2 = GraphConv(n_classes, activation='softmax', use_bias=False)
def create_model(self): X_in = Input((self.features.shape[1],)) fltr_in = Input((self.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(GCN.labels.shape[1], use_bias=True)(X_4) return Model(inputs=[X_in, fltr_in], outputs=X_5)
def Model_treeGCN_softmax_1(node_count, wordvocabsize, w2v_k, word_W, l2_reg=5e-4): X_word_in = Input(shape=(node_count, ), dtype='int32') # fltr_in = Input(shape=(node_count, node_count), sparse=True) fltr_in = Input(tensor=sp_matrix_to_sp_tensor(fltr)) word_embedding_layer = Embedding(input_dim=wordvocabsize + 1, output_dim=w2v_k, input_length=node_count, mask_zero=True, trainable=True, weights=[word_W]) word_embedding_x = word_embedding_layer(X_word_in) word_embedding_x = Dropout(0.25)(word_embedding_x) graph_conv_1 = GraphConv(200, activation='relu', kernel_regularizer=l2(l2_reg), use_bias=True)([word_embedding_x, fltr_in]) dropout_1 = Dropout(0.5)(graph_conv_1) graph_conv_2 = GraphConv(200, activation='relu', kernel_regularizer=l2(l2_reg), use_bias=True)([dropout_1, fltr_in]) dropout_2 = Dropout(0.5)(graph_conv_2) feature_node0 = Lambda(lambda x: x[:, 0])(dropout_2) # pool = GlobalAttentionPool(200)(dropout_2) flatten = Flatten()(dropout_2) fc = Dense(512, activation='relu')(flatten) fc = Dropout(0.5)(fc) # LSTM_backward = LSTM(200, activation='tanh', return_sequences=False, # go_backwards=True, dropout=0.5)(dropout_2) # present_node0 = concatenate([feature_node0, LSTM_backward], axis=-1) class_output = Dense(120)(fc) class_output = Activation('softmax', name='CLASS')(class_output) # Build model model = Model(inputs=[X_word_in, fltr_in], outputs=class_output) optimizer = Adam(lr=0.001) model.compile(optimizer=optimizer, loss='categorical_crossentropy', weighted_metrics=['acc']) return model
def build_model(self, N, F, num_outputs): X_in = Input(shape=(N, F), name='X_in') A_in = Input(shape=(N, N), name='A_in') RL_indice = Input(shape=(N), name='rl_indice_in') ### Encoder x = Dense(32, activation='relu', name='encoder_1')(X_in) x = Dense(32, activation='relu', name='encoder_2')(x) ### Graphic convolution x1 = GraphConv(32, activation='relu', name='gcn1')([x, A_in]) x1 = Dense(32, activation='relu', name='post_gcn_1')(x1) # x2 = GraphConv(32, activation='relu',name='gcn2')([x1, A_in]) # x2 = Dense(32,activation='relu',name='post_gcn_2')(x2) ### Action and filter x3 = Concatenate()([x, x1]) x3 = Dense(64, activation='relu', name='policy_1')(x3) x3 = Dense(32, activation='relu', name='policy_2')(x3) x3 = Dense(num_outputs, activation='linear', name='policy_output')(x3) mask = Reshape((N, 1), name='expend_dim')(RL_indice) qout = Multiply(name='filter')([x3, mask]) model = Model(inputs=[X_in, A_in, RL_indice], outputs=[qout]) print(model.summary()) return model
def conv_layer(row, col, x): conv = tf.keras.layers.Conv1D(hidden_dim * 2, 5, padding='same', activation='tanh', input_shape=(row, col))(x) gcn_1 = GraphConv( graph_channels, activation='tanh', )([conv, As_in[:, :, :, 1]]) gcn_2 = ChebConv( graph_channels, activation='tanh', )([conv, As_in[:, :, :, 1]]) gcn_3 = ARMAConv( graph_channels, activation='tanh', )([conv, As_in[:, :, :, 1]]) gcn_1 = tf.keras.layers.Concatenate()([gcn_1, gcn_2, gcn_3]) gcn_1 = tf.keras.layers.Conv1D(3 * graph_channels, 5, padding='same', activation='tanh', input_shape=(row, col))(gcn_1) conv = tf.keras.layers.Concatenate()([x, conv, gcn_1, gcn_2, gcn_3]) conv = tf.keras.layers.Activation("relu")(conv) conv = tf.keras.layers.SpatialDropout1D(0.1)(conv) return conv
def pose_model(): sensor_matrix = Input(shape=(num_sensors, num_sensors)) s_input1, extract_cnn1 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) s_input2, extract_cnn2 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) s_input3, extract_cnn3 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) s_input4, extract_cnn4 = resnet_sensor_network(input_shape, repetitions=[2,2,2,2]) pose_input1 = Input(shape=(2)) s_pose1 = Dense(64, activation='relu')(pose_input1) pose_input2 = Input(shape=(2)) s_pose2 = Dense(64, activation='relu')(pose_input2) pose_input3 = Input(shape=(2)) s_pose3 = Dense(64, activation='relu')(pose_input3) pose_input4 = Input(shape=(2)) s_pose4 = Dense(64, activation='relu')(pose_input4) extract_cnn1 = Concatenate(axis=-1)([extract_cnn1, Reshape((1,s_pose1.shape[-1]))(s_pose1)]) extract_cnn2 = Concatenate(axis=-1)([extract_cnn2, Reshape((1,s_pose2.shape[-1]))(s_pose2)]) extract_cnn3 = Concatenate(axis=-1)([extract_cnn3, Reshape((1,s_pose3.shape[-1]))(s_pose3)]) extract_cnn4 = Concatenate(axis=-1)([extract_cnn4, Reshape((1,s_pose4.shape[-1]))(s_pose4)]) extract_cnn = Concatenate(axis=1)([extract_cnn1, extract_cnn2, extract_cnn3, extract_cnn4]) #extract_cnn = np.reshape(extract_cnn, (-1,)) G_1 = GraphConv(256, 'relu')([extract_cnn, sensor_matrix]) G_2 = GraphConv(256, 'relu')([G_1, sensor_matrix]) gnn_output = tf.split(G_2, num_sensors, 1) output1 = Dense(32, activation='relu')(Flatten()(gnn_output[0])) output1 = Dense(1, activation='linear', name='sensor_1')(output1) output2 = Dense(32, activation='relu')(Flatten()(gnn_output[1])) output2 = Dense(1, activation='linear', name='sensor_2')(output2) output3 = Dense(32, activation='relu')(Flatten()(gnn_output[2])) output3 = Dense(1, activation='linear', name='sensor_3')(output3) output4 = Dense(32, activation='relu')(Flatten()(gnn_output[3])) output4 = Dense(1, activation='linear', name='sensor_4')(output4) model = Model(inputs=[s_input1, s_input2, s_input3, s_input4, s_pose1, s_pose2, s_pose3, s_pose4, sensor_matrix], outputs= [output1,output2,output3,output4]) return model
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]
def make_discriminator(name, s, adj, node_f, use_gcn=True, use_gru=True): n = node_f.shape[0] # number of nodes input_s = Input(shape=(s, n)) input_f = Input(shape=(n, node_f.shape[1])) input_g = Input(shape=(n, n)) if use_gcn: gcov1 = GraphConv(2 * base)([input_f, input_g]) # gcov2 = GraphConv(base)([gcov1, input_g]) input_s1 = Dot(axes=(2, 1))( [input_s, gcov1]) # dot product: element by element multiply else: input_s1 = input_s fc1 = Dense(4 * base, activation='relu', input_shape=(n, ))(input_s1) fc2 = Dense(8 * base, activation='relu', input_shape=(n, ))(fc1) # S*D2 if use_gru: rnn1 = Dropout(dropout)(CuDNNGRU(2 * base, return_sequences=True)(fc2)) else: rnn1 = fc2 fc3 = Dense(16 * base, activation='relu', input_shape=(n, ))(rnn1) out = Dense(1)(Flatten()(fc3)) return Model(name=name, inputs=[input_s, input_f, input_g], outputs=out)
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)
def khop_model_distribute(num_sensors=10): # input/output = num of sensors gnn_unit = 128 sensor_matrix1 = Input(shape=(num_sensors, num_sensors)) sensor_matrix2 = Input(shape=(num_sensors, num_sensors)) sensor_matrix3 = Input(shape=(num_sensors, num_sensors)) sensor_matrix4 = Input(shape=(num_sensors, num_sensors)) #sensor_matrix3 = Input(shape=(num_sensors, num_sensors)) s_input1 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input2 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input3 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input4 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input5 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input6 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input7 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input8 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input9 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_input10 = Input(shape=(input_shape[0], input_shape[1], input_shape[2])) s_cnn = sensor_cnn(input_shape, repetitions=[2, 2, 2, 2]) extract_cnn1 = s_cnn(s_input1) extract_cnn2 = s_cnn(s_input2) extract_cnn3 = s_cnn(s_input3) extract_cnn4 = s_cnn(s_input4) extract_cnn5 = s_cnn(s_input5) extract_cnn6 = s_cnn(s_input6) extract_cnn7 = s_cnn(s_input7) extract_cnn8 = s_cnn(s_input8) extract_cnn9 = s_cnn(s_input9) extract_cnn10 = s_cnn(s_input10) extract_cnn = Concatenate(axis=1)([ extract_cnn1, extract_cnn2, extract_cnn3, extract_cnn4, extract_cnn5, extract_cnn6, extract_cnn7, extract_cnn8, extract_cnn9, extract_cnn10 ]) #extract_cnn = np.reshape(extract_cnn, (-1,)) G_h1 = GraphConv(gnn_unit, 'selu')([extract_cnn, sensor_matrix1]) G_h2 = GraphConv(gnn_unit, 'selu')([extract_cnn, sensor_matrix2]) G_h3 = GraphConv(gnn_unit, 'selu')([extract_cnn, sensor_matrix3]) G_h4 = GraphConv(gnn_unit, 'selu')([extract_cnn, sensor_matrix4]) G_1 = Concatenate(axis=-1)([G_h1, G_h2, G_h3, G_h4]) G_2h1 = GraphConv(gnn_unit, 'selu')([G_1, sensor_matrix1]) G_2h2 = GraphConv(gnn_unit, 'selu')([G_1, sensor_matrix2]) G_2h3 = GraphConv(gnn_unit, 'selu')([G_1, sensor_matrix3]) G_2h4 = GraphConv(gnn_unit, 'selu')([G_1, sensor_matrix4]) G_2 = Concatenate(axis=-1)([G_2h1, G_2h2, G_2h3, G_2h4]) #G_3h1 = GraphConv(gnn_unit, 'selu')([G_2, sensor_matrix1]) #G_3h2 = GraphConv(gnn_unit, 'selu')([G_2, sensor_matrix2]) #G_3h3 = GraphConv(gnn_unit, 'selu')([G_2, sensor_matrix3]) #G_3h4 = GraphConv(gnn_unit, 'selu')([G_2, sensor_matrix4]) #G_3 = Concatenate(axis=-1)([G_3h1, G_3h2, G_3h3, G_3h4]) #G_4h1 = GraphConv(gnn_unit, 'selu')([G_3, sensor_matrix1]) #G_4h2 = GraphConv(gnn_unit, 'selu')([G_3, sensor_matrix2]) #G_4h3 = GraphConv(gnn_unit, 'selu')([G_3, sensor_matrix3]) #G_4h4 = GraphConv(gnn_unit, 'selu')([G_3, sensor_matrix4]) #G_4 = Concatenate(axis=-1)([G_4h1, G_4h2, G_4h3, G_4h4]) gnn_output = tf.split(G_2, num_sensors, 1) mlp_layer = mlp_model() output1 = mlp_layer(Flatten()(gnn_output[0])) output2 = mlp_layer(Flatten()(gnn_output[1])) output3 = mlp_layer(Flatten()(gnn_output[2])) output4 = mlp_layer(Flatten()(gnn_output[3])) output5 = mlp_layer(Flatten()(gnn_output[4])) output6 = mlp_layer(Flatten()(gnn_output[5])) output7 = mlp_layer(Flatten()(gnn_output[6])) output8 = mlp_layer(Flatten()(gnn_output[7])) output9 = mlp_layer(Flatten()(gnn_output[8])) output10 = mlp_layer(Flatten()(gnn_output[9])) model = Model(inputs=[ s_input1, s_input2, s_input3, s_input4, s_input5, s_input6, s_input7, s_input8, s_input9, s_input10, sensor_matrix1, sensor_matrix2, sensor_matrix3, sensor_matrix4 ], outputs=[ output1, output2, output3, output4, output5, output6, output7, output8, output9, output10 ]) return model
va_mask = np.zeros(N, dtype=bool) va_mask[va_idx] = True te_mask = np.zeros(N, dtype=bool) te_mask[te_idx] = True masks = [tr_mask, va_mask, te_mask] # Parameters channels = 256 learning_rate = 1e-2 epochs = 200 es_patience = 200 F = X.shape[1] n_classes = y.shape[1] # Preprocessing operations fltr = GraphConv.preprocess(A).astype('f4') # Model definition X_in = Input(shape=(F, )) fltr_in = Input((N, ), sparse=True) graph_conv_1 = GraphConv(channels, activation='relu')([X_in, fltr_in]) graph_conv_2 = GraphConv(channels, activation='relu')([graph_conv_1, fltr_in]) graph_conv_3 = GraphConv(n_classes)([graph_conv_2, fltr_in]) # Build model model = Model(inputs=[X_in, fltr_in], outputs=graph_conv_3) optimizer = Adam(lr=learning_rate) model.compile(optimizer=optimizer, loss=BinaryCrossentropy(from_logits=True)) model.summary() # Train model
def main(time_train, epochs, C_i, C_o, learning_rate, kernel, regenerate=False): os.chdir(os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]) if (not os.path.exists('/media/data6TB/spandan/data.p')) or regenerate: from data_utils import load_data X, A, E = load_data( DATASET='data-all.json', R=300, SIGMA=1 ) # Shapes: (171, 640, 3) (171, 640, 640) (171, 640, 640, 1) with open('/media/data6TB/spandan/data.p', 'wb') as pkl: pickle.dump((X, A, E), pkl) else: with open('/media/data6TB/spandan/data.p', 'rb') as pkl: X, A, E = pickle.load(pkl) districts = A.shape[1] # Inputs X_in = Input(shape=(districts, C_i), batch_size=time_train) E_in = Input(shape=(districts, districts, 1), batch_size=time_train) A_in = Input(shape=(districts, districts), batch_size=time_train) # Block X_i0 = tf.transpose(tf.expand_dims(X_in, axis=0), perm=[0, 2, 1, 3]) l1 = GLU(filters=2 * C_o, kernelsize=kernel)(X_i0) X_i1 = tf.squeeze(tf.transpose(l1, perm=[0, 2, 1, 3])) E_i1 = E_in[:X_i1.shape[0], :, :, :] A_i1 = A_in[:X_i1.shape[0], :, :] l1 = GraphConv(channels=C_i, activation='relu')([X_i1, A_i1, E_i1]) l1 = tf.expand_dims(tf.transpose(l1, perm=[1, 0, 2]), axis=0) l1 = GLU(filters=2 * C_o, kernelsize=kernel)(l1) # Block l2 = GLU(filters=2 * C_o, kernelsize=kernel)(l1) X_i2 = tf.squeeze(tf.transpose(l2, perm=[0, 2, 1, 3])) E_i2 = E_in[:X_i2.shape[0], :, :, :] A_i2 = A_in[:X_i2.shape[0], :, :] l2 = GraphConv(channels=C_i, activation='relu')([X_i2, A_i2, E_i2]) l2 = tf.expand_dims(tf.transpose(l2, perm=[1, 0, 2]), axis=0) l2 = GLU(filters=2 * C_o, kernelsize=kernel)(l2) # Output layer l3 = GLU(filters=2 * C_i, kernelsize=(time_train - 4 * (kernel - 1)))(l2) X_i3 = tf.squeeze(tf.transpose(l3, perm=[0, 2, 1, 3])) final_output = nstack(Dense(C_i)(X_i3), time_train) model = Model(inputs=[X_in, E_in, A_in], outputs=final_output) optimizer = RMSprop(learning_rate=learning_rate) model.compile(optimizer=optimizer, loss='mean_squared_error', weighted_metrics=['acc']) model.summary() X_input = X[:time_train, :, :] E_input = E[:time_train, :, :, :] A_input = localpooling_filter((A[:time_train, :, :]).numpy(), symmetric=True) output = nstack(tf.squeeze(X[time_train, :, :]), time_train) model.fit([X_input, E_input, A_input], output, shuffle=False, epochs=epochs)
print('A', A.shape) print('X', X[0]) # print('y', y) # print('N', N) from spektral.layers import GraphConv from tensorflow.keras.models import Model from tensorflow.keras.layers import Input, Dropout from tensorflow.keras.regularizers import l2 dropout = 0.5 channels = 16 l2_reg = 5e-4 / 2 # Preprocessing operations fltr = GraphConv.preprocess(A).astype('f4') X = X.toarray() X_in = Input(shape=(F, )) fltr_in = Input((N, ), sparse=True) dropout_1 = Dropout(dropout)(X_in) graph_conv_1 = GraphConv(channels, activation='relu', kernel_regularizer=l2(l2_reg), use_bias=False) # dropout_2 = Dropout(dropout)(graph_conv_1) # graph_conv_2 = GraphConv(n_classes, # activation='softmax', # use_bias=False)([dropout_2, fltr_in]) # Build model
[np.random.choice(np.nonzero(labels_one_hot[:, c])[0]) for c in range(4)]) train_mask = np.zeros(shape=labels_one_hot.shape[0], dtype=np.bool) train_mask[labels_to_keep] = ~train_mask[labels_to_keep] val_mask = ~train_mask y_train = labels_one_hot * train_mask[..., np.newaxis] y_val = labels_one_hot * val_mask[..., np.newaxis] # Get important parameters of adjacency matrix N = adj.shape[0] F = 4 # number of features learning_rate = 0.01 epochs = 300 # Preprocessing operations fltr = GraphConv.preprocess(adj).astype('f4') # Model definition X_in = Input(shape=(N, )) fltr_in = Input(shape=(N, )) x = GraphConv(F, activation='tanh', use_bias=False)([X_in, fltr_in]) x = GraphConv(F, activation='tanh', use_bias=False)([x, fltr_in]) x = GraphConv(2, activation='tanh', use_bias=False, name="embedding")([x, fltr_in]) output = GraphConv(4, activation='softmax', use_bias=False)([x, fltr_in]) # Build model model = Model(inputs=[X_in, fltr_in], outputs=output) model.compile(optimizer=Adam(lr=learning_rate), loss='categorical_crossentropy', weighted_metrics=['acc'])
center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', renorm_momentum=0.99, )(area_in) #batch norm on the area data if not include_batch_norm_layers: bn0 = area_in if not include_batch_norm_layers: g1 = GraphConv( embedding_vecor_length1, #first graph conv layer activation='relu', kernel_regularizer=l2(l2_reg), use_bias=True)([bn0, fltr_in]) ac1 = g1 else: g1 = GraphConv( embedding_vecor_length1, #first graph conv layer kernel_regularizer=l2(l2_reg), use_bias=True)([bn0, fltr_in]) bn1 = BN( axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros',
print(X.shape, y.shape, train_mask.shape) # Parameters channels = 16 # Number of channels in the first layer N = X.shape[0] # Number of nodes in the graph print('Number of nodes in the graph N = ', N) F = X.shape[1] # Original size of node features print('Original size of node features F = ', F) n_classes = y.shape[1] # Number of classes dropout = 0.5 # Dropout rate for the features l2_reg = 5e-4 / 2 # L2 regularization rate learning_rate = 1e-2 # Learning rate epochs = 10 # Number of training epochs 200 es_patience = 10 # Patience for early stopping # Preprocessing operations fltr = GraphConv.preprocess(A).astype('f4') X = X.toarray() # Model definition X_in = Input(shape=(F, )) fltr_in = Input((N, ), sparse=True) dropout_1 = Dropout(dropout)(X_in) graph_conv_1 = GraphConv(channels, activation='relu', kernel_regularizer=l2(l2_reg), use_bias=False)([dropout_1, fltr_in]) dropout_2 = Dropout(dropout)(graph_conv_1) graph_conv_2 = GraphConv(n_classes, activation='softmax', use_bias=False)([dropout_2, fltr_in])
es_patience = 10 # Patience fot early stopping log_dir = init_logging() # Create log directory and file # Preprocessing fltr = localpooling_filter(adj.copy()) # Train/test split fltr_train, fltr_test, \ x_train, x_test, \ y_train, y_test = train_test_split(fltr, x, y, test_size=0.1) # Model definition X_in = Input(shape=(N, F)) filter_in = Input((N, N)) gc1 = GraphConv(32, activation='relu', kernel_regularizer=l2(l2_reg))([X_in, filter_in]) gc2 = GraphConv(32, activation='relu', kernel_regularizer=l2(l2_reg))([gc1, filter_in]) pool = GlobalAttentionPool(128)(gc2) output = Dense(n_classes, activation='softmax')(pool) # Build model model = Model(inputs=[X_in, filter_in], outputs=output) optimizer = Adam(lr=learning_rate) model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['acc']) model.summary() # Callbacks
# Preprocessing operations fltr = localpooling_filter(A).astype('f4') X = X.toarray() Ai = A.toarray() fltr1 = fltr.toarray() # Pre-compute propagation for i in range(K - 1): fltr = fltr.dot(fltr) fltr.sort_indices() # Model definition X_in = Input(shape=(F, )) fltr_in = Input((N, ), sparse=True) output = GraphConv(n_classes, activation='softmax', kernel_regularizer=l2(l2_reg), use_bias=False)([X_in, fltr_in]) # Build model model = Model(inputs=[X_in, fltr_in], outputs=output) optimizer = Adam(lr=learning_rate) model.compile(optimizer=optimizer, loss='categorical_crossentropy', weighted_metrics=['acc']) model.summary() # Train model validation_data = ([X, fltr], y, val_mask) model.fit( [X, fltr], y,
can train GCN for 200 epochs in a few tenths of a second (0.32s on a GTX 1050). In total, this script has 34 SLOC. """ import tensorflow as tf from tensorflow.keras.layers import Input, Dropout from tensorflow.keras.models import Model from tensorflow.keras.optimizers import Adam from tensorflow.keras.regularizers import l2 from spektral.datasets import citation from spektral.layers import GraphConv, ops from spektral.utils import tic, toc # Load data A, X, y, train_mask, val_mask, test_mask = citation.load_data('cora') fltr = GraphConv.preprocess(A).astype('f4') fltr = ops.sp_matrix_to_sp_tensor(fltr) X = X.toarray() # Define model X_in = Input(shape=(X.shape[1],)) fltr_in = Input((X.shape[0],), sparse=True) X_1 = GraphConv(16, 'relu', True, kernel_regularizer=l2(5e-4))([X_in, fltr_in]) X_1 = Dropout(0.5)(X_1) X_2 = GraphConv(y.shape[1], 'softmax', True)([X_1, fltr_in]) # Build model model = Model(inputs=[X_in, fltr_in], outputs=X_2) optimizer = Adam(lr=1e-2) model.compile(optimizer=optimizer, loss='categorical_crossentropy') loss_fn = model.loss_functions[0]
X_train, y_train, X_val, y_val, X_test, y_test, adj = 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 = y_train.shape[-1] # Dimension of the target fltr = normalized_laplacian(adj) # 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), use_bias=True)([X_in, A_in]) graph_conv = GraphConv(32, activation='elu', kernel_regularizer=l2(l2_reg), use_bias=True)([graph_conv, A_in]) flatten = Flatten()(graph_conv) fc = Dense(512, activation='relu')(flatten) output = Dense(n_out, activation='softmax')(fc) # Build model model = Model(inputs=[X_in, A_in], outputs=output) optimizer = Adam(lr=learning_rate) model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['acc'])
# 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)
A_in = Input(batch_shape=(None, None), sparse=True) I_in = Input(batch_shape=(None, 1), dtype='int64') # The inputs will have an arbitrary dimension, while the targets consist of # batch_size values. # However, Keras expects the inputs to have the same dimension as the output. # This is a hack in Tensorflow to bypass the requirements of Keras. # We use a dynamically initialized tf.Dataset to feed the target values to the # model at training time. target_ph = tf.placeholder(tf.float32, shape=(None, 1)) target_data = tf.data.Dataset.from_tensor_slices(target_ph) target_data = target_data.batch(batch_size) target_iter = target_data.make_initializable_iterator() target = target_iter.get_next() gc1 = GraphConv(64, activation='relu')([X_in, A_in]) gc2 = GraphConv(64, activation='relu')([gc1, A_in]) pool = GlobalAvgPool()([gc2, I_in]) dense1 = Dense(64, activation='relu')(pool) output = Dense(n_out)(dense1) # Build model model = Model(inputs=[X_in, A_in, I_in], outputs=output) optimizer = Adam(lr=learning_rate) model.compile(optimizer=optimizer, loss='mse', target_tensors=target) model.summary() # Training setup sess = K.get_session() batches_train = batch_iterator([A_train, X_train, y_train], batch_size=batch_size, epochs=epochs) loss = 0
X, A, _, y = ogb.dataset_to_numpy(dataset, dtype='f8') A = [a.toarray() for a in A] F = X[0].shape[-1] X = pad_jagged_array(X, (N, F)) A = pad_jagged_array(A, (N, N)) X_tr, A_tr, y_tr = X[tr_idx], A[tr_idx], y[tr_idx] X_va, A_va, y_va = X[va_idx], A[va_idx], y[va_idx] X_te, A_te, y_te = X[te_idx], A[te_idx], y[te_idx] ################################################################################ # BUILD MODEL ################################################################################ X_in = Input(shape=(N, F)) A_in = Input(shape=(N, N)) X_1 = GraphConv(32, activation='relu')([X_in, A_in]) X_1, A_1 = MinCutPool(N // 2)([X_1, A_in]) X_2 = GraphConv(32, activation='relu')([X_1, A_1]) X_3 = GlobalSumPool()(X_2) output = Dense(n_out)(X_3) # Build model model = Model(inputs=[X_in, A_in], outputs=output) opt = Adam(lr=learning_rate) model.compile(optimizer=opt, loss='mse') model.summary() ################################################################################ # FIT MODEL ################################################################################ model.fit([X_tr, A_tr],
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,
N = A.shape[0] F = X.shape[-1] n_classes = y.shape[-1] # %% X[1, 2] # %% 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() # %%