feature_layer = Dense(hs2, weights=[weights_fea.T, rbm4.intercept_hidden_], activation='sigmoid', name='merged_layer_2')(merge_layer_2) # decoding print('decoding processing \n') merge_layer_2_t = Dense(hs1, weights=[weights_fea, rbm4.intercept_visible_], activation='sigmoid',name='merge_layer_2_t')(feature_layer) merge_xy_t = Dense(merge_hs,weights=[weights_merge, rbm3.intercept_visible_], activation='sigmoid',name='merge_t')(merge_layer_2_t) x_hidden_t = Lambda(get_eeg_part, output_shape=(eeg_hs,))(merge_xy_t) y_hidden_t = Lambda(get_eye_part, output_shape=(eye_hs,))(merge_xy_t) x_recon = Dense(x_col, weights=[weights_eeg, rbm1.intercept_visible_], activation='sigmoid',name='x_recon')(x_hidden_t) y_recon = Dense(y_col, weights=[weights_eye, rbm2.intercept_visible_], activation='sigmoid',name='y_recon')(y_hidden_t) model = Model(input=[x_input, y_input], output=[x_recon, y_recon]) adam = Adam(lr=lr) model.compile(optimizer=adam,loss='mean_squared_error') model.fit([eeg_train, eye_train],[eeg_train, eye_train], nb_epoch=500, batch_size=100) adam.lr = lr2 labels = Dense(3,name='svm',W_regularizer=l2(l2_reg))(feature_layer) model2 = Model(input=[x_input, y_input], output=[labels]) model2.compile(optimizer=adam,loss='hinge') for i in range(7): model2.layers[i].set_weights(model.layers[i].get_weights()) model2.fit([eeg_train,eye_train],train_label,nb_epoch=1000,batch_size=100) feature_res = K.function([model2.layers[0].input, model2.layers[1].input],[model2.layers[6].output]) # this is the middle layer feature_res_below = K.function([model2.layers[0].input, model2.layers[1].input],[model2.layers[5].output]) # this is the layer below the middle layer ## get the extracted feature train_features = feature_res([eeg_train, eye_train])[0] test_features = feature_res([eeg_test, eye_test])[0] eeg_train_features.append(train_features.tolist()) eeg_test_features.append(test_features.tolist())
def train(epochs, batch_size, dataset, baselr, use_pseudounet=False, use_unet=False, use_decay=False, plot_models=True): # Load data and normalize x_train_a, x_train_b, x_test_a, x_test_b = loadImagesFromDataset( h, w, dataset, use_hdf5=False) x_train_a = (x_train_a.astype(np.float32) - 127.5) / 127.5 x_train_b = (x_train_b.astype(np.float32) - 127.5) / 127.5 x_test_a = (x_test_a.astype(np.float32) - 127.5) / 127.5 x_test_b = (x_test_b.astype(np.float32) - 127.5) / 127.5 batchCount_a = x_train_a.shape[0] / batch_size batchCount_b = x_train_b.shape[0] / batch_size # Train on same image amount, would be best to have even sets batchCount = min([batchCount_a, batchCount_b]) print('\nEpochs:', epochs) print('Batch size:', batch_size) print('Batches per epoch: ', batchCount, "\n") #Retrieve components and save model before training, to preserve weights initialization disc_a, disc_b, gen_a2b, gen_b2a = components(w, h, pseudounet=use_pseudounet, unet=use_unet, plot=plot_models) saveModels(0, gen_a2b, gen_b2a, disc_a, disc_b) #Initialize fake images pools pool_a2b = [] pool_b2a = [] # Define optimizers adam_disc = Adam(lr=baselr, beta_1=0.5) adam_gen = Adam(lr=baselr, beta_1=0.5) # Define image batches true_a = gen_a2b.inputs[0] true_b = gen_b2a.inputs[0] fake_b = gen_a2b.outputs[0] fake_a = gen_b2a.outputs[0] fake_pool_a = K.placeholder(shape=(None, 3, h, w)) fake_pool_b = K.placeholder(shape=(None, 3, h, w)) # Labels for generator training y_fake_a = K.ones_like(disc_a([fake_a])) y_fake_b = K.ones_like(disc_b([fake_b])) # Labels for discriminator training y_true_a = K.ones_like(disc_a([true_a])) * 0.9 y_true_b = K.ones_like(disc_b([true_b])) * 0.9 fakelabel_a2b = K.zeros_like(disc_b([fake_b])) fakelabel_b2a = K.zeros_like(disc_a([fake_a])) # Define losses disc_a_loss = mse_loss(y_true_a, disc_a([true_a])) + mse_loss( fakelabel_b2a, disc_a([fake_pool_a])) disc_b_loss = mse_loss(y_true_b, disc_b([true_b])) + mse_loss( fakelabel_a2b, disc_b([fake_pool_b])) gen_a2b_loss = mse_loss(y_fake_b, disc_b([fake_b])) gen_b2a_loss = mse_loss(y_fake_a, disc_a([fake_a])) cycle_a_loss = mae_loss(true_a, gen_b2a([fake_b])) cycle_b_loss = mae_loss(true_b, gen_a2b([fake_a])) cyclic_loss = cycle_a_loss + cycle_b_loss # Prepare discriminator updater discriminator_weights = disc_a.trainable_weights + disc_b.trainable_weights disc_loss = (disc_a_loss + disc_b_loss) * 0.5 discriminator_updater = adam_disc.get_updates(discriminator_weights, [], disc_loss) # Prepare generator updater generator_weights = gen_a2b.trainable_weights + gen_b2a.trainable_weights gen_loss = (gen_a2b_loss + gen_b2a_loss + lmda * cyclic_loss) generator_updater = adam_gen.get_updates(generator_weights, [], gen_loss) # Define trainers generator_trainer = K.function([true_a, true_b], [gen_a2b_loss, gen_b2a_loss, cyclic_loss], generator_updater) discriminator_trainer = K.function( [true_a, true_b, fake_pool_a, fake_pool_b], [disc_a_loss / 2, disc_b_loss / 2], discriminator_updater) epoch_counter = 1 # Start training for e in range(1, epochs + 1): print('\n', '-' * 15, 'Epoch %d' % e, '-' * 15) #Learning rate decay if use_decay and (epoch_counter > 100): lr -= baselr / 100 adam_disc.lr = lr adam_gen.lr = lr # Initialize progbar and batch counter #progbar = generic_utils.Progbar(batchCount) np.random.shuffle(x_train_a) np.random.shuffle(x_train_b) # Cycle through batches for i in trange(int(batchCount)): # Select true images for training #true_batch_a = x_train_a[np.random.randint(0, x_train_a.shape[0], size=batch_size)] #true_batch_b = x_train_b[np.random.randint(0, x_train_b.shape[0], size=batch_size)] true_batch_a = x_train_a[i * batch_size:i * batch_size + batch_size] true_batch_b = x_train_b[i * batch_size:i * batch_size + batch_size] # Fake images pool a2b = gen_a2b.predict(true_batch_a) b2a = gen_b2a.predict(true_batch_b) tmp_b2a = [] tmp_a2b = [] for element in a2b: if len(pool_a2b) < 50: pool_a2b.append(element) tmp_a2b.append(element) else: p = random.uniform(0, 1) if p > 0.5: index = random.randint(0, 49) tmp = np.copy(pool_a2b[index]) pool_a2b[index] = element tmp_a2b.append(tmp) else: tmp_a2b.append(element) for element in b2a: if len(pool_b2a) < 50: pool_b2a.append(element) tmp_b2a.append(element) else: p = random.uniform(0, 1) if p > 0.5: index = random.randint(0, 49) tmp = np.copy(pool_b2a[index]) pool_b2a[index] = element tmp_b2a.append(tmp) else: tmp_b2a.append(element) pool_a = np.array(tmp_b2a) pool_b = np.array(tmp_a2b) # Update network and obtain losses disc_a_err, disc_b_err = discriminator_trainer( [true_batch_a, true_batch_b, pool_a, pool_b]) gen_a2b_err, gen_b2a_err, cyclic_err = generator_trainer( [true_batch_a, true_batch_b]) # progbar.add(1, values=[ # ("D A", disc_a_err*2), # ("D B", disc_b_err*2), # ("G A2B loss", gen_a2b_err), # ("G B2A loss", gen_b2a_err), # ("Cyclic loss", cyclic_err) # ]) # Save losses for plotting disc_a_history.append(disc_a_err) disc_b_history.append(disc_b_err) gen_a2b_history_new.append(gen_a2b_err) gen_b2a_history_new.append(gen_b2a_err) #cycle_history.append(cyclic_err[0]) plotLoss_new() plotGeneratedImages(epoch_counter, x_test_a, x_test_b, gen_a2b, gen_b2a) if epoch_counter > 150: saveModels(epoch_counter, gen_a2b, gen_b2a, disc_a, disc_b) epoch_counter += 1
from experiment_utils import * from report_generation import * ## one time parameter for the model below ## regularizer ## l2 ker_reg = 0.1 act_reg = 0.1 ## kernel_initializer ker_init = initializers.glorot_normal(seed=None) ## shape in_shape = (648, 4) ## learning rate opt = Adam() opt.lr = 0.0001 ## OUTPUT_SIZE = 2 ## batch size bsize = 50 ## epochs = 30 ## callback ##model_callback = TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=False) csv_logger = CSVLogger("./logs/cnn_1_proof.log.csv") def make_model(): ## model ## resample data to 648 * 1 model = Sequential() ## 1d conv, size 3 filter, 64 filters, stride 1