def objective_pseudobs(x_train, neurons, drop, activation, lr_opt, optimizer,
n_layers):
n_epochs = 100
in_features = x_train.shape[1]
model = Sequential()
model.add(Dense(neurons, input_dim=in_features, activation=activation))
model.add(BatchNormalization(epsilon=1e-05, momentum=0.1))
model.add(Dropout(rate=drop))
if n_layers > 1:
model.add(Dense(neurons, activation=activation))
model.add(BatchNormalization(epsilon=1e-05, momentum=0.1))
model.add(Dropout(rate=drop))
if n_layers == 3:
model.add(Dense(neurons, activation=activation))
model.add(BatchNormalization(epsilon=1e-05, momentum=0.1))
model.add(Dropout(rate=drop))
model.add(Dense(1, activation='sigmoid'))
if optimizer == "rmsprop":
optim = optimizers.RMSprop(learning_rate=lr_opt, rho=0.9)
ca = [Callback()]
elif optimizer == "adam":
optim = optimizers.Adam(learning_rate=lr_opt,
beta_1=0.9,
beta_2=0.999,
amsgrad=False)
ca = [Callback()]
elif optimizer == "adam_amsgrad":
optim = optimizers.Adam(learning_rate=lr_opt,
beta_1=0.9,
beta_2=0.999,
amsgrad=True)
ca = [Callback()]
elif optimizer == "sgdwr":
optim = optimizers.SGD(momentum=0.9)
n_cycles = n_epochs / 50
ca = [CosineAnnealingLearningRateSchedule(n_epochs, n_cycles, 0.01)]
model.compile(optimizer=optim, loss='mean_squared_error')
return (model, ca)
def train(self, X, Y, epoch_ypred=False, epoch_xtest=None):
""" Fit the neural network model, save additional stats (as attributes) and return Y predicted values.
Parameters
----------
X : array-like, shape = [n_samples, n_features]
Predictor variables, where n_samples is the number of samples and n_features is the number of predictors.
Y : array-like, shape = [n_samples, 1]
Response variables, where n_samples is the number of samples.
Returns
-------
y_pred_train : array-like, shape = [n_samples, 1]
Predicted y score for samples.
"""
# # If using Keras, set tf to 1 core
# config = K.tf.ConfigProto(intra_op_parallelism_threads=8, inter_op_parallelism_threads=8, allow_soft_placement=True)
# session = tf.Session(config=config)
# K.set_session(session)
# If batch-size is None:
if self.batch_size is None:
self.batch_size = len(X)
self.model = Sequential()
self.model.add(Dense(self.n_neurons, activation="sigmoid", input_dim=len(X.T)))
self.model.add(Dense(1, activation="linear"))
self.model.compile(optimizer=self.optimizer, loss=self.loss, metrics=["accuracy"])
# If epoch_ypred is True, calculate ypred for each epoch
if epoch_ypred is True:
self.epoch = YpredCallback(self.model, X, epoch_xtest)
else:
self.epoch = Callback()
# Fit
self.model.fit(X, Y, epochs=self.n_epochs, batch_size=self.batch_size, verbose=self.verbose, callbacks=[self.epoch])
layer1_weight = self.model.layers[0].get_weights()[0]
layer1_bias = self.model.layers[0].get_weights()[1]
layer2_weight = self.model.layers[1].get_weights()[0]
layer2_bias = self.model.layers[1].get_weights()[1]
# Not sure about the naming scheme (trying to match PLS)
self.model.x_loadings_ = layer1_weight
self.model.x_scores_ = np.matmul(X, self.model.x_loadings_) + layer1_bias
self.model.y_loadings_ = layer2_weight
self.model.pctvar_ = np.ones((1, len(self.model.y_loadings_[0])))
self.xcols_num = len(X.T)
self.model.pctvar_ = sum(abs(self.model.x_scores_) ** 2) / sum(sum(abs(X) ** 2)) * 100
y_pred_train = self.model.predict(X).flatten()
# Storing X, Y, and Y_pred
self.Y_pred = y_pred_train
self.X = X
self.Y = Y
return y_pred_train
def train(self, X, Y, epoch_ypred=False, epoch_xtest=None):
""" Fit the neural network model, save additional stats (as attributes) and return Y predicted values.
Parameters
----------
X : array-like, shape = [n_samples, n_features]
Predictor variables, where n_samples is the number of samples and n_features is the number of predictors.
Y : array-like, shape = [n_samples, 1]
Response variables, where n_samples is the number of samples.
Returns
-------
y_pred_train : array-like, shape = [n_samples, 1]
Predicted y score for samples.
"""
# If batch-size is None:
if self.batch_size is None:
self.batch_size = len(X)
self.model = Sequential()
self.model.add(
Dense(self.n_neurons, activation="sigmoid", input_dim=len(X.T)))
self.model.add(Dense(len(Y[0]), activation="softmax"))
self.model.compile(optimizer=self.optimizer,
loss=self.loss,
metrics=["accuracy"])
# If epoch_ypred is True, calculate ypred for each epoch
if epoch_ypred is True:
self.epoch = YpredCallback(self.model, X, epoch_xtest)
else:
self.epoch = Callback()
# Fit
self.model.fit(X,
Y,
epochs=self.n_epochs,
batch_size=self.batch_size,
verbose=self.verbose,
callbacks=[self.epoch])
y_pred_train = self.model.predict(X)
# Storing X, Y, and Y_pred
self.Y_pred = y_pred_train
self.X = X
self.Y = Y
return y_pred_train
def __init__(self, input, output, name='RDNN'):
# super(Dnn, self).__init__()
self.name = name
features_1 = Input(shape=(input, ))
e1 = Dense(6000,
input_dim=input,
activation='sigmoid',
W_regularizer=regularizers.l2(l=0.))(features_1)
e1 = normalization.BatchNormalization()(e1)
f = Dense(3500,
activation='sigmoid',
W_regularizer=regularizers.l2(l=0.))(e1)
f = normalization.BatchNormalization()(f)
out = Dense(output, activation='linear', name="Synsets")(f)
out = CustomActivation(activation='custom_mixed_activation')(out)
model = Model(input=features_1, output=out)
self.check_stop = Callback()
self.model = model
def __init__(self, input, output, name='DNN'):
# super(Dnn, self).__init__()
self.name = name
model = Sequential()
model.add(
Dense(4000,
input_dim=input,
activation='sigmoid',
W_regularizer=regularizers.l2(l=0.)))
# model.add(advanced_activations.LeakyReLU(alpha=0.1))
model.add(normalization.BatchNormalization())
model.add(
Dense(2000,
activation='sigmoid',
W_regularizer=regularizers.l2(l=0.)))
# model.add(advanced_activations.LeakyReLU(alpha=0.1))
model.add(normalization.BatchNormalization())
model.add(Dense(output, activation='sigmoid'))
self.check_stop = Callback()
self.model = model
def model_fit(model, x, y, batch_size=1024, epochs=40):
s = datetime.datetime.now()
log = Callback()
his = model.fit(
x,
y,
batch_size=batch_size,
epochs=epochs,
verbose=1,
callbacks=[log],
validation_split=0.1,
)
t = datetime.datetime.now() - s
t = str(t).split('.')[0]
print('cost time {} '.format(t)) # 21:34:00
tem = his.history
loss = str(tem['loss'][len(tem)])[:5]
val_loss = str(tem['val_loss'][len(tem)])[:5]
his_data = pd.DataFrame()
his_data['loss'] = tem['loss']
his_data['val_loss'] = tem['val_loss']
return model, t, loss, val_loss, his_data
def train(self):
model = self.prepare_model()
training_info = self.get_training_info()
epoch_count = training_info['epoch']
def on_epoch_end(epoch, log):
nonlocal epoch_count
epoch_count += 1
self.store_training_info({
'epoch': epoch_count,
'val_acc': log['val_acc'],
'train_loss': log['loss'],
'val_loss': log['val_loss']
})
training_info_call_back = Callback()
training_info_call_back.on_epoch_end = on_epoch_end
model.fit(self.train_x, self.train_y,
batch_size=2, epochs=100,
validation_data=(self.test_x, self.test_y),
initial_epoch=epoch_count, callbacks=[ModelCheckpoint(self.model_weight), training_info_call_back])
tbCallBack = TensorBoard(
log_dir=
'C:/Users/baseb/Desktop/MachineLearning1/Building Classifier CNN/logs/',
histogram_freq=0,
batch_size=1,
write_graph=True,
write_grads=False,
write_images=True,
embeddings_freq=0,
embeddings_layer_names=None,
embeddings_metadata=None)
a = adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(loss='categorical_crossentropy',
optimizer=a,
metrics=['accuracy'])
Callback()
earlyStop = EarlyStopping(monitor='loss',
min_delta=0,
patience=15,
verbose=2,
mode='auto')
callbacks_list = [tbCallBack, earlyStop]
model.fit(trainData,
trainLabels,
batch_size=1,
epochs=300,
validation_data=(testData, testLabels),
verbose=2,
callbacks=callbacks_list)
#convout1_f = theano.function([model.get_input(train=False)], convout1.get_output(train=False))
def train(self,
X,
Y,
epoch_ypred=False,
epoch_xtest=None,
w1=False,
w2=False):
""" Fit the neural network model, save additional stats (as attributes) and return Y predicted values.
Parameters
----------
X : array-like, shape = [n_samples, n_features]
Predictor variables, where n_samples is the number of samples and n_features is the number of predictors.
Y : array-like, shape = [n_samples, 1]
Response variables, where n_samples is the number of samples.
Returns
-------
y_pred_train : array-like, shape = [n_samples, 1]
Predicted y score for samples.
"""
# # If using Keras, set tf to 1 core
# config = K.tf.ConfigProto(intra_op_parallelism_threads=8, inter_op_parallelism_threads=8, allow_soft_placement=True)
# session = tf.Session(config=config)
# K.set_session(session)
# If batch-size is None:
if self.batch_size is None:
self.batch_size = len(X)
self.X = X
self.Y = Y
# If epoch_ypred is True, calculate ypred for each epoch
if epoch_ypred is True:
self.epoch = YpredCallback(self.model, X, epoch_xtest)
else:
self.epoch = Callback()
if self.compiled == False:
np.random.seed(self.seed)
self.model = Sequential()
self.model.add(
Dense(self.n_neurons, activation="linear", input_dim=len(X.T)))
self.model.add(Dense(1, activation="sigmoid"))
self.model.compile(optimizer=self.optimizer,
loss=self.loss,
metrics=["accuracy"])
self.model.w1 = self.model.layers[0].get_weights()
self.model.w2 = self.model.layers[1].get_weights()
self.compiled == True
else:
self.model.layers[0].set_weights(self.model.w1)
self.model.layers[1].set_weights(self.model.w2)
#print("Before: {}".format(self.model.layers[1].get_weights()[0].flatten()))
# print("Before: {}".format(self.model.layers[1].get_weights()[0]))
if w1 != False:
self.model.layers[0].set_weights(w1)
self.model.w1 = w1
if w2 != False:
self.model.layers[1].set_weights(w2)
self.model.w2 = w2
# Fit
self.model.fit(X,
Y,
epochs=self.n_epochs,
batch_size=self.batch_size,
verbose=self.verbose)
self.model.pctvar_ = pctvar_calc(self.model, X, Y)
#print("After: {} .... {}".format(self.model.layers[1].get_weights()[0].flatten(), self.model.pctvar_))
layer1_weight = self.model.layers[0].get_weights()[0]
layer1_bias = self.model.layers[0].get_weights()[1]
layer2_weight = self.model.layers[1].get_weights()[0]
layer2_bias = self.model.layers[1].get_weights()[1]
# Coef vip
self.model.vip_ = garson(layer1_weight, layer2_weight.flatten())
self.model.coef_ = connectionweight(layer1_weight,
layer2_weight.flatten())
# Not sure about the naming scheme (trying to match PLS)
self.model.x_loadings_ = layer1_weight
self.model.x_scores_ = np.matmul(X,
self.model.x_loadings_) + layer1_bias
self.model.x_scores_alt = self.model.x_scores_
self.model.y_loadings_ = layer2_weight
self.model.y_scores = np.matmul(self.model.x_scores_alt,
self.model.y_loadings_) + layer2_bias
y_pred_train = self.model.predict(X).flatten()
# Sort by pctvar
# if self.compiled == False:
# if w1 == False:
# if w2 == False:
# order = np.argsort(self.model.pctvar_)[::-1]
# self.model.x_scores_ = self.model.x_scores_[:, order]
# self.model.x_loadings_ = self.model.x_loadings_[:, order]
# self.model.y_loadings_ = self.model.y_loadings_[order]
# self.model.y_loadings_ = self.model.y_loadings_.T
# self.model.pctvar_ = self.model.pctvar_[order]
# self.model.w1[0] = self.model.w1[0][:, order]
# self.model.w2[0] = self.model.w2[0][order]
# self.compiled = True
self.model.y_loadings_ = layer2_weight.T
# Calculate pfi
if self.pfi_nperm == 0:
self.model.pfi_acc_ = np.zeros((1, len(Y)))
self.model.pfi_r2q2_ = np.zeros((1, len(Y)))
self.model.pfi_auc_ = np.zeros((1, len(Y)))
else:
pfi_acc, pfi_r2q2, pfi_auc = self.pfi(nperm=self.pfi_nperm,
metric=self.pfi_metric,
mean=self.pfi_mean)
self.model.pfi_acc_ = pfi_acc
self.model.pfi_r2q2_ = pfi_r2q2
self.model.pfi_auc_ = pfi_auc
self.Y_train = Y
self.Y_pred_train = y_pred_train
self.Y_pred = y_pred_train
self.X = X
self.Y = Y
self.metrics_key = []
self.model.eval_metrics_ = []
bm = binary_evaluation(Y, y_pred_train)
for key, value in bm.items():
self.model.eval_metrics_.append(value)
self.metrics_key.append(key)
self.model.eval_metrics_ = np.array(self.model.eval_metrics_)
return y_pred_train
def build_model_pseudobs(x_train, neurons, drop, activation, lr_opt, optimizer,
n_layers, n_epochs):
""" Define the structure of the neural network for models with pseudo-observations (optim, continuous, discrete, km)
# Arguments
x_train: input data as formated by the function "prepare_data"
neurons: number of neurons per hidden layer in the neural network
drop: dropout rate applied after each hidden layer
activation: activation function applied after each hidden layer
lr_opt: learning rate chosen for optimization
optimizer: optimization algorithm
n_layers: number of hidden layers
n_epochs: number of epochs used for training the model
# Returns
model: keras model with the architecture defined previously
callbacks: callbacks function
"""
in_features = x_train.shape[1]
model = Sequential()
model.add(Dense(neurons, input_dim=in_features, activation=activation))
model.add(BatchNormalization(epsilon=1e-05, momentum=0.1))
model.add(Dropout(rate=drop))
if n_layers > 1:
model.add(Dense(neurons, activation=activation))
model.add(BatchNormalization(epsilon=1e-05, momentum=0.1))
model.add(Dropout(rate=drop))
if n_layers == 3:
model.add(Dense(neurons, activation=activation))
model.add(BatchNormalization(epsilon=1e-05, momentum=0.1))
model.add(Dropout(rate=drop))
model.add(Dense(1, activation='sigmoid'))
if optimizer == "RMSprop":
optim = optimizers.RMSprop(learning_rate=lr_opt, rho=0.9)
callbacks = [Callback()]
elif optimizer == "Adam":
optim = optimizers.Adam(learning_rate=lr_opt,
beta_1=0.9,
beta_2=0.999,
amsgrad=False)
callbacks = [Callback()]
elif optimizer == "Adam_AMSGrad":
optim = optimizers.Adam(learning_rate=lr_opt,
beta_1=0.9,
beta_2=0.999,
amsgrad=True)
callbacks = [Callback()]
elif optimizer == "SGDWR":
optim = optimizers.SGD(momentum=0.9)
n_cycles = n_epochs / 50
callbacks = [
CosineAnnealingLearningRateSchedule(n_epochs, n_cycles, 0.01)
]
model.compile(optimizer=optim, loss='mean_squared_error')
return (model, callbacks)
def main(batch_size=32,
eval_interval=10,
epochs=100000,
image_size=224,
loss_threshold=-0.1,
color_space='yuv',
train_data_dir='/mnt/bolbol/raw-data/train',
log_dir='logs',
models_save_dir='coloring_models',
colored_images_save_dir='colored_images',
vgg=False,
feature_extractor_model_path=None,
train_feature_extractor=False,
classifier=False,
populate_batches=1000,
scale_factor=9.,
colorizer_model_path=None,
include_target_image=False):
""" Train Wasserstein gan to colorize black and white images """
''' Prepare data generators '''
image_generator = ImageDataGenerator().flow_from_directory(
directory=train_data_dir,
interpolation='bilinear',
target_size=(image_size, image_size),
batch_size=batch_size,
color_mode='rgb',
class_mode=None)
data_mapper, class_weights = get_mapping_with_class_weights(
classifier=classifier,
color_space=color_space,
image_generator=image_generator,
image_size=image_size,
nb_batches=populate_batches,
scale_factor=scale_factor,
calculate_weights=False)
gray_image_generator = ImageGenerator(
rgb_generator=image_generator,
input_processing_function=data_mapper.rgb_to_colorizer_input)
real_image_generator = ImageGenerator(
rgb_generator=image_generator,
input_processing_function=data_mapper.rgb_to_target_image)
gray_with_target_generator = ImageGenerator(
rgb_generator=image_generator,
input_processing_function=data_mapper.rgb_to_colorizer_input,
label_processing_function=data_mapper.rgb_to_colorizer_target)
test_data_generator = ImageGenerator(
rgb_generator=image_generator,
input_processing_function=data_mapper.rgb_to_colorizer_input,
label_processing_function=lambda x: x)
''' Prepare Models '''
colorizer = get_colorizer(
colorizer_model_path=colorizer_model_path,
image_size=None,
vgg=vgg,
feature_extractor_model_path=feature_extractor_model_path,
train_feature_extractor=train_feature_extractor,
classifier=classifier,
classes_per_pixel=data_mapper.nb_classes if classifier else 0)
critic = get_critic(image_size=image_size)
critic.compile(optimizer=Adam(lr=0.00001, beta_1=0.5, beta_2=0.9),
loss=wasserstein_loss)
combined = get_combined_gan(
classifier=classifier,
class_to_color=data_mapper.class_to_color if classifier else None,
generator=colorizer,
critic=critic,
image_size=image_size,
include_colorizer_output=include_target_image)
combined.compile(optimizer=Adam(lr=0.00001, beta_1=0.5, beta_2=0.9),
loss=[
wasserstein_loss,
'categorical_crossentropy' if classifier else 'mse'
] if include_target_image else [wasserstein_loss])
''' View summary of the models '''
print('\n\n\n\nColorizer:'), colorizer.summary()
print('\n\n\n\nCritic:'), critic.summary()
print('\n\n\n\nCombined:'), combined.summary()
logger = keras.callbacks.TensorBoard(
log_dir=log_dir) if K.backend() == 'tensorflow' else Callback()
gym = Gym(generator=colorizer,
critic=critic,
combined=combined,
gray_image_generator=gray_image_generator,
real_image_generator=real_image_generator,
gray_with_target_generator=gray_with_target_generator,
test_data_generator=test_data_generator,
data_mapper=data_mapper,
logger=logger,
models_save_dir=models_save_dir,
colored_images_save_dir=colored_images_save_dir,
classifier=classifier)
gym.train(loss_threshold=loss_threshold,
eval_interval=eval_interval,
epochs=epochs,
include_target_image=include_target_image)
K.clear_session()
np.random.seed(1337)
set_random_seed(1337)
labels = "bleach_with_non_chlorine, do_not_bleach, do_not_dryclean, do_not_tumble_dry, do_not_wash, double_bar, dryclean, low_temperature_tumble_dry, normal_temperature_tumble_dry, single_bar, tumble_dry, wash_30, wash_40, wash_60, wash_hand"
labels = labels.split(", ")
img2_shape = (int(360), int(360), 3)
X_train, y_train, val_X_2, val_y_2 = get_features_and_labels_validation(
img2_shape, val_size=0.2)
a = list(range(len(y_train)))
np.random.shuffle(a)
y_train = y_train[a]
X_train = X_train[a]
cb = Callback()
filepath = "weights-improvement-{epoch:02d}.hdf5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_hn_multilabel_loss',
verbose=1,
save_best_only=True,
mode='min')
reduceLROnPlat = ReduceLROnPlateau(monitor='val_hn_multilabel_loss',
factor=0.1,
patience=3,
verbose=1,
mode='min',
cooldown=2,
min_lr=0.000000001)
erly_s = EarlyStopping(monitor='val_hn_multilabel_loss', patience=7)
cb_list = [cb, checkpoint, erly_s, reduceLROnPlat]
paddinglayer = ZeroPadding1D(padding=half_window_size)(word_emb)
conv = Conv1D(nb_filter=50,
filter_length=(2 * half_window_size + 1),
border_mode='valid')(paddinglayer)
conv_d = Dropout(0.1)(conv)
dense_conv = TimeDistributed(Dense(50))(conv_d)
rnn_cnn_merge = merge([bilstm_d, dense_conv], mode='concat', concat_axis=2)
dense = TimeDistributed(Dense(nb_tag))(rnn_cnn_merge)
crf = ChainCRF()
crf_output = crf(dense)
model = Model(input=[word_input], output=[crf_output])
model.compile(loss=crf.sparse_loss,
optimizer=RMSprop(0.00001),
metrics=['sparse_categorical_accuracy'])
model.summary()
model.load_weights('model.weights')
mCallBack = Callback()
model.fit(X_train,
Y_train,
batch_size=batch_size,
nb_epoch=10,
callbacks=[mCallBack])
model.save_weights('model.weights')
def train_model(model, data, config, include_tensorboard):
model_history = History()
model_history.on_train_begin()
saver = ModelCheckpoint(full_path(config.model_file()), verbose=1, save_best_only=True, period=1)
saver.set_model(model)
early_stopping = EarlyStopping(min_delta=config.min_delta, patience=config.patience, verbose=1)
early_stopping.set_model(model)
early_stopping.on_train_begin()
csv_logger = CSVLogger(full_path(config.csv_log_file()))
csv_logger.on_train_begin()
if include_tensorboard:
tensorborad = TensorBoard(histogram_freq=10, write_images=True)
tensorborad.set_model(model)
else:
tensorborad = Callback()
epoch = 0
stop = False
while(epoch <= config.max_epochs and stop == False):
epoch_history = History()
epoch_history.on_train_begin()
valid_sizes = []
train_sizes = []
print("Epoch:", epoch)
for dataset in data.datasets:
print("dataset:", dataset.name)
model.reset_states()
dataset.reset_generators()
valid_sizes.append(dataset.valid_generators[0].size())
train_sizes.append(dataset.train_generators[0].size())
fit_history = model.fit_generator(dataset.train_generators[0],
dataset.train_generators[0].size(),
nb_epoch=1,
verbose=0,
validation_data=dataset.valid_generators[0],
nb_val_samples=dataset.valid_generators[0].size())
epoch_history.on_epoch_end(epoch, last_logs(fit_history))
train_sizes.append(dataset.train_generators[1].size())
fit_history = model.fit_generator(dataset.train_generators[1],
dataset.train_generators[1].size(),
nb_epoch=1,
verbose=0)
epoch_history.on_epoch_end(epoch, last_logs(fit_history))
epoch_logs = average_logs(epoch_history, train_sizes, valid_sizes)
model_history.on_epoch_end(epoch, logs=epoch_logs)
saver.on_epoch_end(epoch, logs=epoch_logs)
early_stopping.on_epoch_end(epoch, epoch_logs)
csv_logger.on_epoch_end(epoch, epoch_logs)
tensorborad.on_epoch_end(epoch, epoch_logs)
epoch+= 1
if early_stopping.stopped_epoch > 0:
stop = True
early_stopping.on_train_end()
csv_logger.on_train_end()
tensorborad.on_train_end({})
def train(self, X, Y, epoch_ypred=False, epoch_xtest=None):
""" Fit the neural network model, save additional stats (as attributes) and return Y predicted values.
Parameters
----------
X : array-like, shape = [n_samples, n_features]
Predictor variables, where n_samples is the number of samples and n_features is the number of predictors.
Y : array-like, shape = [n_samples, 1]
Response variables, where n_samples is the number of samples.
Returns
-------
y_pred_train : array-like, shape = [n_samples, 1]
Predicted y score for samples.
"""
# If batch-size is None:
if self.batch_size is None:
self.batch_size = len(X)
X1 = X[0]
X2 = X[1]
# Layer for X1
input_X1 = Input(shape=(len(X1.T), ))
layer1_X1 = Dense(self.n_neurons_l1, activation="linear")(input_X1)
layer1_X1 = Model(inputs=input_X1, outputs=layer1_X1)
# Layer for X2
input_X2 = Input(shape=(len(X2.T), ))
layer1_X2 = Dense(self.n_neurons_l1, activation="linear")(input_X2)
layer1_X2 = Model(inputs=input_X2, outputs=layer1_X2)
# Concatenate
concat = concatenate([layer1_X1.output, layer1_X2.output])
#model_concat = Dense(self.n_neurons_l2, activation="sigmoid")(concat)
model_concat = Dense(1, activation="sigmoid")(concat)
self.model = Model(inputs=[layer1_X1.input, layer1_X2.input],
outputs=model_concat)
self.model.compile(optimizer=self.optimizer,
loss=self.loss,
metrics=["accuracy"])
# If epoch_ypred is True, calculate ypred for each epoch
if epoch_ypred is True:
self.epoch = YpredCallback(self.model, X, epoch_xtest)
else:
self.epoch = Callback()
# Fit
self.model.fit([X1, X2],
Y,
epochs=self.n_epochs,
batch_size=self.batch_size,
verbose=self.verbose,
callbacks=[self.epoch])
# Not sure about the naming scheme (trying to match PLS)
y_pred_train = self.model.predict(X).flatten()
# Storing X, Y, and Y_pred
self.Y_pred = y_pred_train
self.X = X
self.Y = Y
return y_pred_train
plt.plot(1 + np.arange(len(val_mse)), val_mse)
plt.title('mse', fontsize=18)
plt.xlabel('time', fontsize=18)
plt.ylabel('mse', fontsize=18)
plt.legend(['Training', 'Validation'], loc='upper left')
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
plt.show()
epochs = 200
batch_size = 64
Nval = 200
control_val = True
save_training_tensorboard = False
callbacks = Callback()
if not control_val:
history = model.fit(X_train,
y_train,
epochs=epochs,
batch_size=batch_size,
verbose=2)
else:
acum_tr_mse = []
acum_val_mse = []
filepath = "./best_model.h5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_mse',
verbose=2,
