def train_sample(model, select_env, sensor_locs, num_sensors, num_iter, ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4, batch_size, if_att=True): input_data, output_data = load_data(num_iter, select_env, num_sensors, sensor_locs) input_data2 = np.array(input_data) output_data2 = np.array(output_data) batch_matrix1 = np.zeros((data_per_epoch, num_sensors, num_sensors)) batch_matrix2 = np.zeros((data_per_epoch, num_sensors, num_sensors)) batch_matrix3 = np.zeros((data_per_epoch, num_sensors, num_sensors)) batch_matrix4 = np.zeros((data_per_epoch, num_sensors, num_sensors)) for j in range(data_per_epoch): if if_att == False: batch_matrix1[j] = localpooling_filter(ad_matrix1) batch_matrix2[j] = localpooling_filter(ad_matrix2) batch_matrix3[j] = localpooling_filter(ad_matrix3) batch_matrix4[j] = localpooling_filter(ad_matrix4) else: batch_matrix1[j] = ad_matrix1 batch_matrix2[j] = ad_matrix2 batch_matrix3[j] = ad_matrix3 batch_matrix4[j] = ad_matrix4 batch_input = [] batch_output = [] for k in range(num_sensors): batch_input.append(input_data2[:, k]) batch_output.append(output_data2[:, k]) for k in range(4): exec("batch_input.append(batch_matrix{})".format(k + 1)) history = model.fit(x=batch_input, y=batch_output, batch_size=batch_size, epochs=1, shuffle=True) #callbacks=[TensorBoard(log_dir='mytensorboard')]) model.save('train_data1101/gnn_dyna_1102.h5') del model K.clear_session() gc.collect() #history = 0 return history
def __init__(self, channels, adj, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super().__init__(activity_regularizer=activity_regularizer, **kwargs) self.channels = channels self.adj = adj self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.supports_masking = False fltr = localpooling_filter(self.adj) self.fltr = sp_matrix_to_sp_tensor(fltr)
def evaluate_actions(self, state, action): if self.is_cnn == False: cur_obs = np.zeros((len(state), 10, 84, 336, 3)) ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4 = [], [], [], [] for j in range(len(state)): new_state = form_obs(state[j], self.sensor_obs) cur_obs[j] = new_state robot_pos = [-state[j][-1][0][5], 0.5, state[j][-1][0][3]] new_matrix1, new_matrix2, new_matrix3, new_matrix4 = cal_admatrix( robot_pos, self.env_index) if self.is_att == False: ad_matrix1.append(localpooling_filter(new_matrix1)) ad_matrix2.append(localpooling_filter(new_matrix2)) ad_matrix3.append(localpooling_filter(new_matrix2)) ad_matrix4.append(localpooling_filter(new_matrix2)) else: ad_matrix1.append(new_matrix1) ad_matrix2.append(new_matrix2) ad_matrix3.append(new_matrix2) ad_matrix4.append(new_matrix2) output, value = self.policy([ cur_obs[:, 0], cur_obs[:, 1], cur_obs[:, 2], cur_obs[:, 3], cur_obs[:, 4], cur_obs[:, 5], cur_obs[:, 6], cur_obs[:, 7], cur_obs[:, 8], cur_obs[:, 9], ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4 ]) else: cur_obs = np.zeros((len(state), 1, 84, 336, 3)) for j in range(len(state)): new_state = form_obs(state[j]) cur_obs[j] = new_state robot_pos = [-state[j][-1][0][5], 0.5, state[j][-1][0][3]] output, value = self.policy_cnn([cur_obs[:, 0]]) #output = tf.clip_by_value(output, -1, 1) dist = self.get_dist(tf.cast(output, dtype=tf.float32)) if not self.discrete: action = (action - self.action_shift) / self.action_bound log_probs = dist.log_prob(action) #action = tf.clip_by_value(action, -1, 1) if not self.discrete: log_probs = tf.reduce_sum(log_probs, axis=-1) entropy = dist.entropy() return log_probs, entropy, value
def train_sample(model, select_env, num_sensors=10, num_iter=train_iter, if_att=False): input_data, output_data, ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4 = sample_batch( num_iter, select_env, num_sensors) batch_input = np.array(input_data) batch_output = np.array(output_data) batch_matrix1 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix2 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix3 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix4 = np.zeros((batch_size, num_sensors, num_sensors)) for j in range(batch_size): if if_att == False: batch_matrix1[j] = localpooling_filter(ad_matrix1) batch_matrix2[j] = localpooling_filter(ad_matrix2) batch_matrix3[j] = localpooling_filter(ad_matrix3) batch_matrix4[j] = localpooling_filter(ad_matrix4) else: batch_matrix1[j] = ad_matrix1 batch_matrix2[j] = ad_matrix2 batch_matrix3[j] = ad_matrix3 batch_matrix4[j] = ad_matrix4 history = model.fit(x=[ batch_input[:, 0], batch_input[:, 1], batch_input[:, 2], batch_input[:, 3], batch_input[:, 4], batch_input[:, 5], batch_input[:, 6], batch_input[:, 7], batch_input[:, 8], batch_input[:, 9], batch_matrix1, batch_matrix2, batch_matrix3, batch_matrix4 ], y=[ batch_output[:, 0], batch_output[:, 1], batch_output[:, 2], batch_output[:, 3], batch_output[:, 4], batch_output[:, 5], batch_output[:, 6], batch_output[:, 7], batch_output[:, 8], batch_output[:, 9] ], batch_size=batch_size, epochs=1, shuffle=True) #callbacks=[TensorBoard(log_dir='mytensorboard')]) return model, history
def train_sample(): init_lr = 3e-5 for num_iter in range(train_iter): print('start_training round:', num_iter) if num_iter == int(train_iter/4): new_lr = init_lr/10 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) if num_iter == int(train_iter/2): new_lr = init_lr/100 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) if num_iter == int(train_iter/1.3): new_lr = init_lr/1000 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) input_data, output_data, ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4 = sample_batch(batch_size) for i in range(4): batch_input = np.array(input_data[i]) batch_output = np.array(output_data[i]) batch_matrix1 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix2 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix3 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix4 = np.zeros((batch_size, num_sensors, num_sensors)) for j in range(batch_size): batch_matrix1[j] = localpooling_filter(ad_matrix1[i]) batch_matrix2[j] = localpooling_filter(ad_matrix2[i]) batch_matrix3[j] = localpooling_filter(ad_matrix3[i]) batch_matrix4[j] = localpooling_filter(ad_matrix4[i]) history = model.fit(x = [batch_input[:,0], batch_input[:,1], batch_input[:,2], batch_input[:,3], batch_input[:,4], batch_input[:,5], batch_input[:,6], batch_input[:,7], batch_input[:,8], batch_matrix1, batch_matrix2, batch_matrix3, batch_matrix4], y = [batch_output[:,0], batch_output[:,1], batch_output[:,2], batch_output[:,3], batch_output[:,4], batch_output[:,5], batch_output[:,6], batch_output[:,7], batch_output[:,8]], batch_size=batch_size, epochs=1, shuffle = True) #callbacks=[TensorBoard(log_dir='mytensorboard')]) hist_df = pd.DataFrame(history.history) hist_csv_file = 'history0910.csv' with open(hist_csv_file, mode='a') as f: hist_df.to_csv(f) if num_iter % 500 == 100: print('save_model') model.save('gnn_0911.h5')
def act(self, state, test=False): if self.is_cnn == False: robot_pos = [-state[-1][0][5], 0.5, state[-1][0][3]] cur_obs = form_obs(state) #cur_obs = np.expand_dims(state, axis=0).astype(np.float32) ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4 = cal_admatrix( robot_pos, self.env_index) if self.is_att == False: ad_matrix1, ad_matrix2 = localpooling_filter( ad_matrix1), localpooling_filter(ad_matrix2) ad_matrix3, ad_matrix4 = localpooling_filter( ad_matrix3), localpooling_filter(ad_matrix4) else: pass output, value = self.policy.predict([ np.expand_dims(cur_obs[0], axis=0), np.expand_dims(cur_obs[1], axis=0), np.expand_dims(cur_obs[2], axis=0), np.expand_dims(cur_obs[3], axis=0), np.expand_dims(cur_obs[4], axis=0), np.expand_dims(cur_obs[5], axis=0), np.expand_dims(cur_obs[6], axis=0), np.expand_dims(cur_obs[7], axis=0), np.expand_dims(cur_obs[8], axis=0), np.expand_dims(cur_obs[9], axis=0), ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4 ]) else: robot_pos = [-state[-1][0][5], 0.5, state[-1][0][3]] cur_obs = form_obs(state) output, value = self.policy_cnn.predict([cur_obs]) output = tf.clip_by_value(output, -1, 1) dist = self.get_dist(output) if self.discrete: action = tf.math.argmax(output, axis=-1) if test else dist.sample() log_probs = dist.log_prob(action) else: action = output if test else dist.sample() action = tf.clip_by_value(action, -1, 1) #action = action.astype(np.float32) log_probs = tf.reduce_sum(dist.log_prob(action), axis=-1) action = action * self.action_bound + self.action_shift return action[0].numpy(), value[0][0], log_probs[0].numpy()
# Log variables log(__file__) vars_to_log = [ 'SEED', 'N_SAMPLES_IN_BASE', 'N_SAMPLES_IN_CLASS', 'N', 'F', 'latent_space', 'radius', 'sigma', 'learning_rate', 'epochs', 'batch_size', 'es_patience', 'live_classes', 'optimizer', 'losses' ] log(''.join('- {}: {}\n'.format(v, str(eval(v))) for v in vars_to_log)) # Data normalization print('Preprocessing data.') ss = StandardScaler() nf = ss.fit_transform(nf.reshape(-1, F)).reshape(-1, N, F) nf_live = ss.transform(nf_live.reshape(-1, F)).reshape(-1, N, F) fltr = localpooling_filter(adj) fltr_live = localpooling_filter(adj_live) # Train/test split adj_train, adj_test, \ fltr_train, fltr_test, \ nf_train, nf_test = train_test_split(adj, fltr, nf, test_size=0.1) # Train/val split adj_train, adj_val, \ fltr_train, fltr_val, \ nf_train, nf_val = train_test_split(adj_train, fltr_train, nf_train, test_size=0.1) # Autoencoder model = GAE_CCM(N, F,
# Load data adj, x, y = delaunay.generate_data(return_type='numpy', classes=[0, 5]) # Parameters N = x.shape[-2] # Number of nodes in the graphs F = x.shape[-1] # Original feature dimensionality n_classes = y.shape[-1] # Number of classes l2_reg = 5e-4 # Regularization rate for l2 learning_rate = 1e-3 # Learning rate for Adam epochs = 200 # Number of training epochs batch_size = 32 # Batch size 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)
def preprocess(A): return localpooling_filter(A)
def train_sample(if_att=False): init_lr = 3e-5 for num_iter in range(train_iter): print('start_training round:', num_iter) if num_iter == int(train_iter / 4): new_lr = init_lr / 10 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) if num_iter == int(train_iter / 2): new_lr = init_lr / 100 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) if num_iter == int(train_iter / 1.3): new_lr = init_lr / 1000 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) input_data, output_data, ad_matrix1, ad_matrix2, ad_matrix3, ad_matrix4, num_sensors = sample_batch( batch_size) for i in range(1): # num of different batches, currently is 1 ''' if num_sensors == 9: for z_i in range(len(input_data[i])): input_data[i][z_i] = np.concatenate((input_data[i][z_i], np.zeros((1,84,336,3))), axis=0 ) output_data[i][z_i] = np.concatenate((output_data[i][z_i], np.zeros((1,2))), axis=0) num_sensors = 10 ad_matrix1[i] = np.concatenate((ad_matrix1[i], np.zeros((1,9))), axis=0) ad_matrix1[i] = np.concatenate((ad_matrix1[i], np.zeros((10,1))), axis=-1) ad_matrix2[i] = np.concatenate((ad_matrix2[i], np.zeros((1,9))), axis=0) ad_matrix2[i] = np.concatenate((ad_matrix2[i], np.zeros((10,1))), axis=-1) ad_matrix3[i] = np.concatenate((ad_matrix3[i], np.zeros((1,9))), axis=0) ad_matrix3[i] = np.concatenate((ad_matrix3[i], np.zeros((10,1))), axis=-1) ad_matrix4[i] = np.concatenate((ad_matrix4[i], np.zeros((1,9))), axis=0) ad_matrix4[i] = np.concatenate((ad_matrix4[i], np.zeros((10,1))), axis=-1) ''' batch_input = np.array(input_data[i]) batch_output = np.array(output_data[i]) batch_matrix1 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix2 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix3 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix4 = np.zeros((batch_size, num_sensors, num_sensors)) for j in range(batch_size): if if_att == False: batch_matrix1[j] = localpooling_filter(ad_matrix1[i]) batch_matrix2[j] = localpooling_filter(ad_matrix2[i]) batch_matrix3[j] = localpooling_filter(ad_matrix3[i]) batch_matrix4[j] = localpooling_filter(ad_matrix4[i]) else: batch_matrix1[j] = ad_matrix1[i] batch_matrix2[j] = ad_matrix2[i] batch_matrix3[j] = ad_matrix3[i] batch_matrix4[j] = ad_matrix4[i] history = model.fit( x=[ batch_input[:, 0], batch_input[:, 1], batch_input[:, 2], batch_input[:, 3], batch_input[:, 4], batch_input[:, 5], batch_input[:, 6], batch_input[:, 7], batch_input[:, 8], #batch_input[:,9], batch_matrix1, batch_matrix2, batch_matrix3, batch_matrix4 ], y=[ batch_output[:, 0], batch_output[:, 1], batch_output[:, 2], batch_output[:, 3], batch_output[:, 4], batch_output[:, 5], batch_output[:, 6], batch_output[:, 7], batch_output[:, 8], #batch_output[:,9] ], batch_size=batch_size, epochs=1, shuffle=True) #callbacks=[TensorBoard(log_dir='mytensorboard')]) hist_df = pd.DataFrame(history.history) hist_csv_file = 'history1002_att.csv' with open(hist_csv_file, mode='a') as f: hist_df.to_csv(f) if num_iter % 500 == 100: print('save_model') model.save('gnn_1002_att.h5')
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)
'filezilla': 0, 'spotifyOnline': 1, 'VLC': 2, 'skype': 3, 'spotifyOffline': 4, 'winscp': 5, 'winrar': 6 } print("started loading saved model") model = tensorflow.saved_model.load('trained') print("finished loading model") Anew, Xnew, _, _, _, _ = prep(input_data) Anew_raw = Anew.toarray() # array from of adj Anew = utils.localpooling_filter(Anew).astype('f4') Xnew = tensorflow.convert_to_tensor(Xnew, float) Anew = tensorflow.convert_to_tensor(Anew.toarray(), float) out = model([Xnew, Anew]) np = out.numpy() pkl.dump(np, open("prediction.pkl", 'wb')) condense_and_plot( input_data, Anew_raw, out.numpy().tolist(), trace_types, # [x/20 for x in range(21)], [0.45],
dataset = 'cora' A, X, y, train_mask, val_mask, test_mask = citation.load_data(dataset) # Parameters channels = 16 # Number of channels in the first layer N = X.shape[0] # Number of nodes in the graph F = X.shape[1] # Original feature dimensionality n_classes = y.shape[1] # Number of classes dropout = 0.5 # Dropout rate applied to the features l2_reg = 5e-4 # Regularization rate for l2 learning_rate = 1e-2 # Learning rate for SGD epochs = 20000 # Number of training epochs es_patience = 200 # Patience for early stopping # Preprocessing operations fltr = localpooling_filter(A) # 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]) # Build model
def train_khop_share(): init_lr = 3e-5 for num_iter in range(train_iter): print('start_training round:', num_iter) if num_iter == int(train_iter/4): new_lr = init_lr/10 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) if num_iter == int(train_iter/2): new_lr = init_lr/100 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) if num_iter == int(train_iter/1.3): new_lr = init_lr/1000 model.compile(optimizer=Adam(learning_rate=new_lr), loss='mse') print('new_learning:', init_lr) #randomly select a batch of sample select_group = np.random.randint(1,total_group1+1) select_group2 = np.random.randint(1,total_group2+1) print('select_env3_:', select_group, ' select_env4_:', select_group2) if select_group == 1: label_path_env3 = "target_env3_1.txt" ad_matrix_env3 = np.load('ad_matrix_env3_1.npy') ad_matrix2_env3 = np.load('ad_matrix2_env3_1.npy') if select_group == 2: label_path_env3 = "target_env3_2.txt" ad_matrix_env3 = np.load('ad_matrix_env3_2.npy') ad_matrix2_env3 = np.load('ad_matrix2_env3_2.npy') if select_group == 3: label_path_env3 = "target_env3_3.txt" ad_matrix_env3 = np.load('ad_matrix_env3_3.npy') ad_matrix2_env3 = np.load('ad_matrix2_env3_3.npy') if select_group == 4: label_path_env3 = "target_env3_4.txt" ad_matrix_env3 = np.load('ad_matrix_env3_4.npy') ad_matrix2_env3 = np.load('ad_matrix2_env3_4.npy') if select_group == 5: label_path_env3 = "target_env3_5.txt" ad_matrix_env3 = np.load('ad_matrix_env3_5.npy') ad_matrix2_env3 = np.load('ad_matrix2_env3_5.npy') if select_group == 6: label_path_env3 = "target_env3_6.txt" ad_matrix_env3 = np.load('ad_matrix_env3_6.npy') ad_matrix2_env3 = np.load('ad_matrix2_env3_6.npy') if select_group2 == 1: label_path_env4 = "target_env4_1.txt" ad_matrix_env4 = np.load('ad_matrix_env4_1.npy') ad_matrix2_env4 = np.load('ad_matrix2_env4_1.npy') if select_group2 == 2: label_path_env4 = "target_env4_2.txt" ad_matrix_env4 = np.load('ad_matrix_env4_2.npy') ad_matrix2_env4 = np.load('ad_matrix2_env4_2.npy') if select_group2 == 3: label_path_env4 = "target_env4_3.txt" ad_matrix_env4 = np.load('ad_matrix_env4_3.npy') ad_matrix2_env4 = np.load('ad_matrix2_env4_3.npy') if select_group2 == 4: label_path_env4 = "target_env4_4.txt" ad_matrix_env4 = np.load('ad_matrix_env4_4.npy') ad_matrix2_env4 = np.load('ad_matrix2_env4_4.npy') if select_group2 == 5: label_path_env4 = "target_env4_5.txt" ad_matrix_env4 = np.load('ad_matrix_env4_5.npy') ad_matrix2_env4 = np.load('ad_matrix2_env4_5.npy') if select_group2 == 6: label_path_env4 = "target_env4_6.txt" ad_matrix_env4 = np.load('ad_matrix_env4_6.npy') ad_matrix2_env4 = np.load('ad_matrix2_env4_6.npy') filePath_env3 = 'training_env3_{}/sensor_1/1'.format(select_group) filelist_env3 = os.listdir(filePath_env3) filelist_env3.sort(key = lambda x: int(x[:-4])) filePath_env4 = 'training_env4_{}/sensor_1/1'.format(select_group2) filelist_env4 = os.listdir(filePath_env4) filelist_env4.sort(key = lambda x: int(x[:-4])) batch_matrix1_env3 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix2_env3 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix1_env4 = np.zeros((batch_size, num_sensors, num_sensors)) batch_matrix2_env4 = np.zeros((batch_size, num_sensors, num_sensors)) for i in range(batch_size): batch_matrix1_env3[i] = localpooling_filter(ad_matrix_env3) batch_matrix2_env3[i] = localpooling_filter(ad_matrix2_env3) batch_matrix1_env4[i] = localpooling_filter(ad_matrix_env4) batch_matrix2_env4[i] = localpooling_filter(ad_matrix2_env4) batch_matrix1 = np.concatenate((batch_matrix1_env3,batch_matrix1_env4), axis=0) batch_matrix2 = np.concatenate((batch_matrix2_env3,batch_matrix2_env4), axis=0) target_label_env3 = open(label_path_env3,"r") target_label_env4 = open(label_path_env4,"r") lines_env3 = target_label_env3.readlines() lines_env4 = target_label_env4.readlines() #select_case_env3 = np.arange(batch_size) select_case_env3 = [np.random.randint(len(lines_env3)) for _ in range(batch_size)] select_case_env4 = [np.random.randint(len(lines_env4)) for _ in range(batch_size)] batch_input_env3 = [] batch_input_env4 = [] batch_output_env3 = s_label_batch(select_group, select_case_env3, 3) batch_output_env4 = s_label_batch(select_group2, select_case_env4, 4) for i in range(batch_size): ####### for env3 all_sensor_input_env3 = np.zeros((num_sensors, 84, 84*4, 3)) for idx_sensor in range(num_sensors): sensor_path = 'training_env3_{}/'.format(select_group) + all_sensors[idx_sensor] img_1 = image.load_img(sensor_path+'/1/'+filelist_env3[select_case_env3[i]], target_size=(84,84)) #height-width img_array_1 = image.img_to_array(img_1) img_2 = image.load_img(sensor_path+'/2/'+filelist_env3[select_case_env3[i]], target_size=(84,84)) #height-width img_array_2 = image.img_to_array(img_2) img_3 = image.load_img(sensor_path+'/3/'+filelist_env3[select_case_env3[i]], target_size=(84,84)) #height-width img_array_3 = image.img_to_array(img_3) img_4 = image.load_img(sensor_path+'/4/'+filelist_env3[select_case_env3[i]], target_size=(84,84)) #height-width img_array_4 = image.img_to_array(img_4) all_sensor_input_env3[idx_sensor,:, 84*3:84*4,:] = img_array_1/255 all_sensor_input_env3[idx_sensor,:, 84*2:84*3,:] = img_array_2/255 all_sensor_input_env3[idx_sensor,:, 84*1:84*2,:] = img_array_3/255 all_sensor_input_env3[idx_sensor,:, 84*0:84*1,:] = img_array_4/255 batch_input_env3.append(all_sensor_input_env3.copy()) for i in range(batch_size): ####### for env4 all_sensor_input_env4 = np.zeros((num_sensors, 84, 84*4, 3)) for idx_sensor in range(num_sensors): sensor_path = 'training_env4_{}/'.format(select_group2) + all_sensors[idx_sensor] img_1 = image.load_img(sensor_path+'/1/'+filelist_env4[select_case_env4[i]], target_size=(84,84)) #height-width img_array_1 = image.img_to_array(img_1) img_2 = image.load_img(sensor_path+'/2/'+filelist_env4[select_case_env4[i]], target_size=(84,84)) #height-width img_array_2 = image.img_to_array(img_2) img_3 = image.load_img(sensor_path+'/3/'+filelist_env4[select_case_env4[i]], target_size=(84,84)) #height-width img_array_3 = image.img_to_array(img_3) img_4 = image.load_img(sensor_path+'/4/'+filelist_env4[select_case_env4[i]], target_size=(84,84)) #height-width img_array_4 = image.img_to_array(img_4) all_sensor_input_env4[idx_sensor,:, 84*3:84*4,:] = img_array_1/255 all_sensor_input_env4[idx_sensor,:, 84*2:84*3,:] = img_array_2/255 all_sensor_input_env4[idx_sensor,:, 84*1:84*2,:] = img_array_3/255 all_sensor_input_env4[idx_sensor,:, 84*0:84*1,:] = img_array_4/255 batch_input_env4.append(all_sensor_input_env4.copy()) # get label data #img_index = int(filelist[select_case[i]][:-4]) batch_input = np.array(batch_input_env3+batch_input_env4) batch_output = np.array(batch_output_env3+batch_output_env4) history = model.fit(x = [batch_input[:,0], batch_input[:,1], batch_input[:,2], batch_input[:,3], batch_input[:,4], batch_input[:,5], batch_input[:,6], batch_input[:,7], batch_input[:,8], batch_matrix1, batch_matrix2], y = [batch_output[:,0], batch_output[:,1], batch_output[:,2], batch_output[:,3], batch_output[:,4], batch_output[:,5], batch_output[:,6], batch_output[:,7], batch_output[:,8]], batch_size=batch_size, epochs=1, shuffle = True) #callbacks=[TensorBoard(log_dir='mytensorboard')]) hist_df = pd.DataFrame(history.history) hist_csv_file = 'cnn_history_mix.csv' with open(hist_csv_file, mode='a') as f: hist_df.to_csv(f) if num_iter % 500 == 100: print('save_model') model.save('gnn_khop_env34_share.h5')
print("Number of classes: {}".format(n_classes)) # print("X shape: {}".format(X)) # Model definition X_in = Input(shape=(F, )) # Input layer for X A_in = Input((None, ), sparse=True) # Input layer for A graph_conv_1 = GraphConv(A.shape[0], activation='relu')([X_in, A_in]) graph_conv_2 = GraphConv(A.shape[0], activation='relu')([graph_conv_1, A_in]) graph_conv_7 = GraphConv(n_classes, activation='softmax')([graph_conv_2, A_in]) graph_conv_8 = GraphConv(n_classes, activation='softmax')([graph_conv_7, A_in]) # Build model model = Model(inputs=[X_in, A_in], outputs=graph_conv_8) A = utils.localpooling_filter(A).astype('f4') model.compile(optimizer="rmsprop", loss='categorical_crossentropy', weighted_metrics=['acc']) model.summary() validation_data = ([X, A], y, val_mask) history = model.fit([X, A], y, sample_weight=train_mask, epochs=60, batch_size=N, validation_data=validation_data, shuffle=False) # Evaluate model
nfeat, adjacency = get_peter_graphs(N, F, T, c_m_o_, distortion) elif problem == 'rotation': nfeat, adjacency = get_rotation_graphs(N, F, T, c_m_o_, distortion, rot_type=rotation_type) else: raise ValueError('Problem can be: peter, rotation') np.savez(log_dir + '{}_{}_original_graph'.format(problem, c_m_o_), nfeat=nfeat, adjacency=adjacency) # Create filters (Laplacian) fltr = localpooling_filter(adjacency.copy()) # Create regressors and targets adj_target = get_targets(adjacency, T, ts) nf_target = get_targets(nfeat, T, ts) fltr = get_input_sequences(fltr, T, ts) node_features = get_input_sequences(nfeat, T, ts) # Split data for sequential tests adj_target_seq = adj_target[T_main:] adj_target = adj_target[:T_main] nf_target_seq = nf_target[T_main:] nf_target = nf_target[:T_main] adj_seq = fltr[T_main:] fltr = fltr[:T_main] nf_seq = node_features[T_main:]