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
