def _build_vae(self):
''' builds variational autoencoder network '''
self.kl_anneal = Input(batch_shape=(self.batch_size, ),
name='kl_anneal')
# build VAE
if np.all(np.array([self.alpha, self.beta, self.lamb]) == 0):
self.x_output = self.decoder(self.encoder(self.enc_x_input))
self.vae = Model(inputs=[self.enc_x_input],
outputs=[self.x_output],
name='variational_autoencoder')
elif self.alpha == self.beta == self.lamb:
self.x_output = self.decoder(self.encoder(self.enc_x_input)[2])
self.vae = Model(inputs=[self.enc_x_input, self.kl_anneal],
outputs=[self.x_output],
name='variational_autoencoder')
tc_loss = self.kl_anneal * self.kullback_leibler_divergence_loss()
self.vae.add_loss(tc_loss)
self.vae.add_metric(tc_loss, name='tc_loss', aggregation='mean')
elif np.any(np.array([self.alpha, self.beta, self.lamb]) > 0):
self.x_output = self.decoder(self.encoder(self.enc_x_input)[2])
self.vae = Model(inputs=[self.enc_x_input, self.kl_anneal],
outputs=[self.x_output],
name='variational_autoencoder')
tc_loss = self.kl_anneal * self.total_correlation_loss()
self.vae.add_loss(tc_loss)
self.vae.add_metric(tc_loss, name='tc_loss', aggregation='mean')
# define VAE optimizer
if self.vae_opt_n == 'sgd':
self.vae_opt = SGD(learning_rate=self.lr)
elif self.vae_opt_n == 'sgdm':
self.vae_opt = SGD(learning_rate=self.lr, momentum=0.5)
elif self.vae_opt_n == 'nsgd':
self.vae_opt = SGD(learning_rate=self.lr,
momentum=0.5,
nesterov=True)
elif self.vae_opt_n == 'rmsprop':
self.vae_opt = RMSprop(learning_rate=self.lr)
elif self.vae_opt_n == 'rmsprop_cent':
self.vae_opt = RMSprop(learning_rate=self.lr, centered=True)
elif self.vae_opt_n == 'adam':
self.vae_opt = Adam(learning_rate=self.lr, beta_1=0.5)
elif self.vae_opt_n == 'adam_ams':
self.vae_opt = Adam(learning_rate=self.lr,
beta_1=0.5,
amsgrad=True)
elif self.vae_opt_n == 'adamax':
self.vae_opt = Adamax(learning_rate=self.lr, beta_1=0.5)
elif self.vae_opt_n == 'adamax_ams':
self.vae_opt = Adamax(learning_rate=self.lr,
beta_1=0.5,
amsgrad=True)
elif self.vae_opt_n == 'nadam':
self.vae_opt = Nadam(learning_rate=self.lr, beta_1=0.5)
# compile VAE
rc_loss = self.reconstruction_loss()
self.vae.add_loss(rc_loss)
self.vae.add_metric(rc_loss, name='rc_loss', aggregation='mean')
self.vae.compile(optimizer=self.vae_opt)
def __init__(
self,
input_shape,
number_of_classes,
filtres=16,
tailleBlock={
'A': 10,
'B': 3,
'C': 3
},
optimiseur='Nadam',
activation='elu',
beta=1.1,
initializer='he_normal',
metrics=['accuracy'],
learningR=None, #0.0005,
nb_gpu=2):
get_custom_objects()['swish'] = swish
get_custom_objects()['e_swish'] = e_swish
self.input_shape = input_shape
self.number_of_classes = number_of_classes
self.filtres = filtres
self.tailleBlock = tailleBlock
#if learningR is not None :
self.optimiseur = optimiseur
if learningR is not None:
self.optimiseur = {
'SGD': SGD(learning_rate=learningR),
'RMSprop': RMSprop(learning_rate=learningR),
'Adagrad': Adagrad(learning_rate=learningR),
'Adadelta': Adadelta(learning_rate=learningR),
'Adam': Adam(learning_rate=learningR),
'Adamax': Adamax(learning_rate=learningR),
'Nadam': Nadam(learning_rate=learningR),
}[optimiseur]
else:
self.optimiseur = {
'SGD': SGD(),
'RMSprop': RMSprop(),
'Adagrad': Adagrad(),
'Adadelta': Adadelta(),
'Adam': Adam(),
'Adamax': Adamax(),
'Nadam': Nadam(),
}[optimiseur]
self.activation = activation
self.initializer = initializer
self.nb_gpu = nb_gpu
self.metrics = metrics
# la valeur 3 indique que les canaux des couleurs sont à la fin
# autrement -1 (je n'utilise pas cette syntaxe )
self.channel_axis = 3
def __init__(self, config):
self.max_iterations = config['PhotometricOptimizer']['max_iterations']
self.termination_crit = config['PhotometricOptimizer'][
'termination_crit']
self.image_height = config['dataset']['image_height']
self.image_width = config['dataset']['image_width']
self.g = Graphics3()
self.optimizer = Adamax(lr=1e-3)
self.timer = Timer(config)
self.angle_th = np.cos(
(config['PhotometricOptimizer']['angle_th'] / 180.0) * np.pi)
self.angle_th = tf.constant(self.angle_th, dtype=tf.float32)
def init_model(self):
self.model = Sequential()
self.model.add(
Dense(self.hidden_units,
input_dim=self.input_units,
activation=self.activation))
self.model.add(
Dropout(self.dropout, noise_shape=self.noise_shape,
seed=self.seed))
self.model.add(
Dense(self.output_units, activation=self.activation_last))
if self.optimizer == 'RMSprop':
opt = RMSprop(learning_rate=self.learning_rate)
elif self.optimizer == 'Adadelta':
opt = kAdadelta(learning_rate=self.learning_rate)
elif self.optimizer == 'SGD':
opt = SGD(learning_rate=self.learning_rate)
elif self.optimizer == 'Adagrad':
opt = Adagrad(learning_rate=self.learning_rate)
elif self.optimizer == 'Adamax':
opt = Adamax(learning_rate=self.learning_rate)
elif self.optimizer == 'Nadam':
opt = Nadam(learning_rate=self.learning_rate)
else:
opt = Adam(learning_rate=self.learning_rate)
self.model.compile(optimizer=opt,
loss=self.loss,
metrics=[self.metrics])
def build_top_nn(input_shape, summary=False):
"""" Return the custom fully connected classifier """
w = TruncatedNormal(mean=0.0, stddev=0.0001, seed=None)
opt = Adamax(learning_rate=0.0001,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0)
model_top = Sequential()
model_top.add(Flatten(input_shape=input_shape))
model_top.add(Dense(16, kernel_initializer=w, bias_initializer='zeros'))
model_top.add(Activation('relu'))
model_top.add(Dropout(0.5))
model_top.add(Dense(1, kernel_initializer=w, bias_initializer='zeros'))
model_top.add(Activation('sigmoid'))
if summary:
print("Top classifier:")
model_top.summary()
model_top.compile(optimizer=opt,
loss='binary_crossentropy',
metrics=['accuracy'])
return model_top
def __init__(self,
img_wt,
img_ht,
flow: Flow = None,
hidden_units=32,
z_size=64,
encoder_strides=[2, 2],
decoder_strides=[2, 2],
callbacks=[],
metrics=[],
output_activation='sigmoid',
loss='binary_crossentropy',
beta_update_fn=None):
super(GatedConvVAE, self).__init__()
if beta_update_fn is None:
beta_update_fn = lambda i, beta: 1.0E-2 * i
self.flow = flow
self.hidden_units = hidden_units
self.z_size = z_size
self.num_downsamples = len(encoder_strides)
self.num_upsamples = len(decoder_strides)
self.encoder_strides = encoder_strides
self.decoder_strides = decoder_strides
self.output_activation = output_activation
self.encoder = self._create_encoder(img_wt, img_ht)
self.decoder, self.flow_layer = self._create_decoder(img_wt, img_ht)
beta_update = LambdaCallback(on_epoch_begin=lambda i, _:
beta_update_fn(i, self.flow_layer.beta))
decoder_output = self.decoder(self.encoder(self.encoder.inputs))
self.model = Model(inputs=self.encoder.inputs,
outputs=decoder_output[0])
self.model.compile(loss=loss,
optimizer=Adamax(learning_rate=1.0E-4, clipnorm=1.),
callbacks=[beta_update] + callbacks,
metrics=metrics)
def create_model(self):
def softmax_ce_logits(y_true, y_pred):
return tf.compat.v1.nn.softmax_cross_entropy_with_logits_v2(
y_true, y_pred)
observation = Input(self.observation_dim, name="o_0")
value, reward, policy_logits, hidden_state = self.initial_inference(
observation)
actions_all, mu_all, loss_all = [], [], []
mu_all += [value,
policy_logits] # TODO: Shouldn't we also add the reward?
loss_all += ["mse", softmax_ce_logits]
for k in range(self.config.num_unroll_steps):
action = Input(self.action_dim, name=f"a_{k}")
actions_all.append(action)
value, reward, policy_logits, hidden_state_n = self.recurrent_inference(
hidden_state, action)
mu_all += [value, reward, policy_logits]
loss_all += ["mse", "mse", softmax_ce_logits]
hidden_state = hidden_state_n # Passback
model = Model([observation] + actions_all, mu_all)
model.compile(Adamax(self.config.learning_rate), loss_all)
return model
def build_triplet_classifier_model(extractor_model,
dist_type='eucl',
threshold=1.0):
anchor_in = Input(shape=(224, 224, 3), name="anchor_in")
anchor_out = extractor_model(anchor_in)
compare_in = Input(shape=(224, 224, 3), name="compare_in")
compare_out = extractor_model(compare_in)
if dist_type == 'cos':
dist = CosineDistance(name="dist")([anchor_out, compare_out])
else:
dist = EuclidianDistanceSquared(name="dist")([anchor_out, compare_out])
model = Lambda(lambda x: tf.cast((x < threshold), tf.float32))(dist)
model = Model([anchor_in, compare_in], model)
model.compile(optimizer=Adamax(),
loss=None,
metrics=[
BinaryAccuracy(),
Precision(),
Recall(),
TrueNegatives(),
FalsePositives(),
FalseNegatives(),
TruePositives()
])
return model
def OptimTypeFunc(x, OpLr, OpMom):
# Function to determine to get desiered optimezer
return {
0: Nadam(lr=OpLr),
1: Adamax(lr=OpLr),
2: SGD(lr=OpLr, momentum=OpMom),
3: Adam(lr=OpLr, clipnorm=1.0),
4: Nadam(lr=OpLr)
}[x]
def build_triplet_training_model(extractor_model,
dist_type='eucl',
alpha=1.0,
optimizer=Adamax()):
triplet_loss = tfa.losses.TripletSemiHardLoss(
margin=alpha,
distance_metric='angular' if (dist_type == 'cos') else 'L2',
name="triplet_loss")
extractor_model.compile(optimizer=optimizer, loss=triplet_loss)
return extractor_model
def PickOptimizer(option='adam', ParamDic={}):
"""
Build an optimizer object.
It gets the type of optimizer needed and the parameters that the users gives.
It adds all the other default parameters and return the object.
Notice: SGD and adam support a learning rate decays the other don't
:param option: string. The type of optimizer desired. Supports: adam
Nadam
Adamax
SGD
:param ParamDic: dictionary. If a parameter is in the dictionary then take that value, if not then use defaults.
:return: A keras optimizer object as desired in the option parameter
"""
# Defaults parameters
DefltInitLearning = 0.001 # 0.0001
DefltBeta1 = 0.9
DefltBeta2 = 0.999
DefltEpsil = 1e-07
DefltAmsgrad = False
DefltAMoment = 0.0
Defltnesterov = False
# Find parameters values
# If the values in the dic. take the value if not then use default
LR = ParamDic['learning_rate'] if 'learning_rate' in ParamDic else DefltInitLearning
BT1 = ParamDic['beta_1'] if 'beta_1' in ParamDic else DefltBeta1
BT2 = ParamDic['beta_2'] if 'beta_2' in ParamDic else DefltBeta2
Eps = ParamDic['epsilon'] if 'epsilon' in ParamDic else DefltEpsil
AMS = ParamDic['amsgrad'] if 'amsgrad' in ParamDic else DefltAmsgrad
MMN = ParamDic['momentum'] if 'momentum' in ParamDic else DefltAMoment
NES = ParamDic['nesterov'] if 'nesterov' in ParamDic else Defltnesterov
if option == 'adam':
opt = Adam(learning_rate=LR, beta_1=BT1, beta_2=BT2, epsilon=Eps, amsgrad=AMS, name='Adam')
elif option == 'Nadam': # Like adam but the momentum also get a direction
opt = Nadam(learning_rate=LR, beta_1=BT1, beta_2=BT2, epsilon=Eps, name='Nadam')
elif option == 'Adamax':
# It is a variant of Adam based on the infinity norm.
# Default parameters follow those provided in the paper.
# Adamax is sometimes superior to adam, specially in models with embeddings.
opt = Adamax(learning_rate=LR, beta_1=BT1, beta_2=BT2, epsilon=Eps, name='Adamax')
elif option == 'SGD':
opt = SGD(learning_rate=LR, momentum=MMN, nesterov=NES, name='SGD')
else:
print('Parameter option was not defined correctly')
return
return opt
def define_generator(latent_dim, n_classes=3):
print("********** ENTERED generator *****************")
##### foundation for labels
in_label = Input(shape=(1, ))
embedding_layer = Embedding(n_classes, 8)
embedding_layer.trainable = True
li = embedding_layer(in_label)
n_nodes = 5 * 5
li = Dense(n_nodes)(li)
li = Reshape((5, 5, 1))(li)
print("generator... n_nodes, li.shape: ", n_nodes, li.shape)
##### foundation for 5x5 image
in_lat = Input(shape=(latent_dim, ))
n_nodes = 128 * 5 * 5
genX = Dense(n_nodes)(in_lat)
genX = LeakyReLU(alpha=0.2)(genX)
genX = Reshape((5, 5, 128))(genX)
dropout = 0.1
print("genX.shape: ", genX.shape)
##### merge image gen and label input
merge = Concatenate()([genX, li])
print("merge.shape: ", merge.shape)
##### create merged model
# upsample to 10x10
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(merge)
print("gen after CV2DT.shape: ", gen.shape)
gen = LeakyReLU(alpha=0.2)(gen)
gen = Dropout(dropout)(gen)
print("gen.shape: ", gen.shape)
# upsample to 20x20
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(gen)
gen = LeakyReLU(alpha=0.2)(gen)
print("gen.shape: ", gen.shape)
# upsample to 40x40
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(gen)
gen = LeakyReLU(alpha=0.2)(gen)
print("gen.shape: ", gen.shape)
# upsample to 80x80
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(gen)
gen = LeakyReLU(alpha=0.2)(gen)
print("gen.shape: ", gen.shape)
# output layer 80x80x3
out_layer = Conv2D(3, (5, 5), activation='tanh', padding='same')(gen)
print("out_layer.shape: ", out_layer.shape)
# define model
model = Model(inputs=[in_lat, in_label], outputs=out_layer)
opt = Adamax(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=10e-8)
model.compile(loss=['binary_crossentropy'], optimizer=opt)
print("\nembedding_layer.get_weights(): \n", embedding_layer.get_weights())
model.summary()
plot_model(model, to_file='cgan/generator_model.png')
return model
def load_pretrained(self, file):
model = tf.keras.models.load_model(file, compile=False)
def softmax_ce_logits(y_true, y_pred):
return tf.compat.v1.nn.softmax_cross_entropy_with_logits_v2(
y_true, y_pred)
loss_all = ["mse", softmax_ce_logits]
for k in range(self.config.num_unroll_steps):
loss_all += ["mse", "mse", softmax_ce_logits]
model.compile(Adamax(self.config.learning_rate), loss_all)
self.model = model
def build_variational(input_shape,
encoder,
layers,
depth,
min_filters=32,
max_filters=256,
lr=1.0E-4):
flow = Invert(
GlowFlow(num_layers=layers,
depth=depth,
coupling_nn_ctor=coupling_nn_glow(min_filters=min_filters,
max_filters=max_filters)))
model = VariationalModel(encoder, normal(), flow)
model.compile(optimizer=Adamax(lr=lr), output_shape=input_shape)
return model
def test_allowed_slot_names(self):
opt_and_slots_pairs = [
(SGD(), []),
(SGD(momentum=0.2), ["momentum"]),
(Adam(), ["m", "v"]),
(Adam(amsgrad=True), ["m", "v", "vhat"]),
(Adamax(), ["m", "v"]),
(Nadam(), ["m", "v"]),
(Adadelta(), ["accum_grad", "accum_var"]),
(Adagrad(), ["accumulator"]),
(Ftrl(), ["accumulator", "linear"]),
(RMSprop(), ["rms"]),
(RMSprop(momentum=0.2), ["rms", "momentum"]),
(RMSprop(centered=True), ["rms", "mg"]),
(RMSprop(momentum=0.2, centered=True), ["rms", "momentum", "mg"]),
]
for opt, expected_slots in opt_and_slots_pairs:
self._compare_slot_names(opt, expected_slots)
def define_gan(g_model, d_model):
print("********** ENTERED gan *****************")
# make weights in the discriminator not trainable
d_model.trainable = False
# get noise and label inputs from generator model
gen_noise, gen_label = g_model.input
# get image output from the generator model
gen_output = g_model.output
# connect image output and label input from generator as inputs to discriminator
gan_output = d_model([gen_output, gen_label])
# define gan model as taking noise and label and outputting a classification
model = Model([gen_noise, gen_label], gan_output)
# compile model
opt = Adamax(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=10e-8)
model.compile(loss='binary_crossentropy', optimizer=opt)
model.summary()
plot_model(model, to_file='cgan/gan_model.png')
return model
def build_multitask_bin_cat_network(nb_classes, char_inputs, char_encoded,
word_inputs, word_encoded, gaze_inputs,
gaze_encoded, gaze):
if gaze:
network = concatenate([gaze_encoded, char_encoded, word_encoded],
name='concat_layer')
else:
network = concatenate([char_encoded, word_encoded],
name='concat_layer')
network = Dense(100, activation='relu', name='common_dense_layer')(network)
bin_output = Dense(1, activation='sigmoid', name='bin_output')(network)
cat_output = Dense(nb_classes, activation='softmax',
name='cat_output')(network)
if gaze:
network_inputs = gaze_inputs + char_inputs + word_inputs
else:
network_inputs = char_inputs + word_inputs
network_outputs = [bin_output, cat_output]
model = Model(inputs=network_inputs,
outputs=network_outputs,
name='ne_model')
adamax = Adamax(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(optimizer=adamax,
loss={
'bin_output': 'binary_crossentropy',
'cat_output': 'categorical_crossentropy'
},
loss_weights={
'bin_output': 1.,
'cat_output': 1.
},
metrics={
'bin_output': [utils.fbeta_score, 'accuracy'],
'cat_output': [utils.fbeta_score, 'accuracy']
})
return model
def _get_optimizer(opt_type, learning_rate):
if opt_type == 'adam':
return Adam(learning_rate=learning_rate)
elif opt_type == 'nadam':
return Nadam(learning_rate=learning_rate)
elif opt_type == 'sgd':
return SGD(learning_rate=learning_rate)
elif opt_type == 'adadelta':
return Adadelta(learning_rate=learning_rate)
elif opt_type == 'adagrad':
return Adagrad(learning_rate=learning_rate)
elif opt_type == 'adamax':
return Adamax(learning_rate=learning_rate)
elif opt_type == 'ftrl':
return Ftrl(learning_rate=learning_rate)
elif opt_type == 'rmsprop':
return RMSprop(learning_rate=learning_rate)
else:
raise NotImplementedError('Optimizer type %s is not implemented.' %
opt_type)
def main(epochs=15, steps_per_epoch=20):
model = get_basic_model(verbose=False)
opt = Adamax()
model.compile(loss="cosine_similarity", optimizer=opt)
preds = []
losses = []
for i in range(1, 6):
filename = ".../data/captions_" + str(i) + ".txt"
print("Current file: " + filename)
batch = next(transfer_generator(filename))
print(decode_binarized_caption(batch[1][0], filename))
H = model.fit(transfer_generator(filename),
epochs=epochs,
steps_per_epoch=steps_per_epoch)
pred = np.round(model.predict(batch[0]))
preds.append(pred)
# print(pred)
# print(batch[1])
# for i in range(10):
# print(decode_binarized_caption(pred[i], filename), decode_binarized_caption(batch[1][i], filename))
losses.append(H.history["loss"])
print('\n')
plot_loss(losses, epochs)
avg_loss_by_file = []
all_loss = []
for loss_file in losses:
avg_loss_by_file.append(np.mean(loss_file))
all_loss = all_loss + loss_file
print("Avg. Loss by Caption file")
print(avg_loss_by_file)
print("Avg. Loss Overall")
print(np.mean(all_loss))
def build_triplet_distances_model(extractor_model,
dist_type='eucl',
alpha=1.0,
add_loss=False):
anchor_in = Input(shape=(224, 224, 3), name="anchor_in")
anchor_out = extractor_model(anchor_in)
pos_in = Input(shape=(224, 224, 3), name="pos_in")
pos_out = extractor_model(pos_in)
neg_in = Input(shape=(224, 224, 3), name="neg_in")
neg_out = extractor_model(neg_in)
if dist_type == 'cos':
pos_dist = CosineDistance(name="pos_dist")([anchor_out, pos_out])
neg_dist = CosineDistance(name="neg_dist")([anchor_out, neg_out])
else:
pos_dist = EuclidianDistanceSquared(name="pos_dist")(
[anchor_out, pos_out])
neg_dist = EuclidianDistanceSquared(name="neg_dist")(
[anchor_out, neg_out])
triplet = TripletLoss(alpha=alpha)([pos_dist, neg_dist])
triplet_model = Model([anchor_in, pos_in, neg_in],
[triplet, pos_dist, neg_dist])
triplet_model.add_metric(pos_dist,
aggregation='mean',
name="pos_dist_mean")
triplet_model.add_metric(neg_dist,
aggregation='mean',
name="neg_dist_mean")
if add_loss:
triplet_model.add_loss(triplet)
else:
triplet_model.add_metric(triplet,
aggregation='mean',
name="triplet_loss_mean")
triplet_model.compile(optimizer=Adamax(), loss=None)
return triplet_model
def initialize_optimizer(optimizer_name: str,
learning_rate: float = None,
decay: float = None,
beta1: float = None,
beta2: float = None,
rho: float = None,
momentum: float = None,
clip_norm=None,
clip_value=None) -> OptimizerType:
"""
Initializes an optimizer based on the user's choices.
Refer to Keras docs for the parameters and the optimizers.
Any parameter which is not used from the given compiler, will be ignored.
:param optimizer_name: the name of the optimizer to be used.
Available names: 'adam', 'rmsprop', 'sgd', 'adagrad', 'adadelta', 'adamax'
:return: the optimizer.
"""
if optimizer_name == 'adam':
opt = Adam(lr=learning_rate, beta_1=beta1, beta_2=beta2, decay=decay)
elif optimizer_name == 'rmsprop':
opt = RMSprop(lr=learning_rate, rho=rho, decay=decay)
elif optimizer_name == 'sgd':
opt = SGD(lr=learning_rate, momentum=momentum, decay=decay)
elif optimizer_name == 'adagrad':
opt = Adagrad(lr=learning_rate, decay=decay)
elif optimizer_name == 'adadelta':
opt = Adadelta(lr=learning_rate, rho=rho, decay=decay)
elif optimizer_name == 'adamax':
opt = Adamax(lr=learning_rate, beta_1=beta1, beta_2=beta2, decay=decay)
else:
raise ValueError('An unexpected optimizer name has been encountered.')
if clip_norm is not None:
opt.clip_norm = clip_norm
if clip_value is not None:
opt.clip_value = clip_value
return opt
def get_optimiser(config: dict):
"""
Choose the correct optimiser.
"""
# Read config
optimiser = config['optimiser']
learning_rate = config['learning_rate']
if optimiser == 'SGD':
return SGD(lr=learning_rate, nesterov=True, momentum=0.9, decay=1e-6)
elif optimiser == 'Adam':
return Adam(lr=learning_rate)
elif optimiser == 'RMSprop':
return RMSprop(lr=learning_rate)
elif optimiser == 'Adagrad':
return Adagrad(lr=learning_rate)
elif optimiser == 'Adadelta':
return Adadelta(lr=learning_rate)
elif optimiser == 'Adamax':
return Adamax(lr=learning_rate)
elif optimiser == 'Nadam':
return Nadam(lr=learning_rate)
def create_prm_optimizer(prm):
if prm['optimizer'] == 'RMSprop':
prm['optimizer_func'] = RMSprop(lr=prm['learning_rate'],
decay=prm['decay'])
if prm['optimizer'] == 'Adam':
prm['optimizer_func'] = Adam(lr=prm['learning_rate'],
decay=prm['decay'])
if prm['optimizer'] == 'AMSgrad':
prm['optimizer_func'] = Adam(lr=prm['learning_rate'],
decay=prm['decay'],
amsgrad=True)
if prm['optimizer'] == 'Adamax':
prm['optimizer_func'] = Adamax(lr=prm['learning_rate'],
decay=prm['decay'])
if prm['optimizer'] == 'Nadam':
prm['optimizer_func'] = Nadam(lr=prm['learning_rate'],
decay=prm['decay'])
return (prm)
## Design network
model = Sequential()
model.add(Masking(mask_value=-9999, input_shape=(a_timesteps, a_features)))
model.add(
LSTM(64,
input_shape=(a_timesteps, a_features),
dropout=0.2,
recurrent_dropout=0.2,
return_sequences=True))
model.add(LSTM(128, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))
model.add(LSTM(32, dropout=0.2, recurrent_dropout=0.2))
#model.add(LSTM(50, input_shape=(a_timesteps, a_features)))
model.add(Dense(1, activation='sigmoid'))
model.compile(
loss='binary_crossentropy',
optimizer=Adamax(lr=0.0001),
metrics=['accuracy'],
)
## Fit network
history = model.fit(train_X,
train_Y,
epochs=70,
batch_size=a_batch_size,
validation_data=(test_X, test_Y),
shuffle=False)
## Plot 예시
plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
def main():
# Obtenemos dos numpy array con las emociones y las imagenes en orden
emotion_array_np, images_array_np = load_data(CSV_FILE)
# Triplicamos las imagenes a 3 capas, para tenerlas en formato RGB, shape(NUM,48,48) --> shape(NUM,48,48,1)
images_array_np = np.broadcast_to(images_array_np[..., None],
images_array_np.shape + (1, ))
# Guardamos el formato de entrada al modelo
initial_inputs = Input(np.shape(images_array_np[0]))
# FORMATO ENTRADA shape(NUM,48,48,1)
# SE DIVIDE EN:
# TRAIN
emotion_train = emotion_array_np[0:NUM_TRAIN]
images_train = images_array_np[0:NUM_TRAIN]
# TEST
emotion_test = emotion_array_np[NUM_TRAIN + 1:]
images_test = images_array_np[NUM_TRAIN + 1:]
# Eliminamos el csv inicial
del (images_array_np, emotion_array_np)
# Preprocesado de imágenes para crear nuevas imágenes
train_datagen = ImageDataGenerator(
# Inclina y estira la imagen
shear_range=0.2,
# Rotaciones aleatorias de 10 grados
rotation_range=10,
# Se aplica de forma aleatoria zoom en las imágenes
zoom_range=0.2,
# Algunas imágenes se girarán horizontalmente
horizontal_flip=True,
# Desplazamientos
# Horizontal
width_shift_range=0.1,
# Vertical
height_shift_range=0.1)
# No hace ningún cambio, solo aplicará el nuevo formato con BATCH
test_datagen = ImageDataGenerator(horizontal_flip=False, zoom_range=0)
data_train = train_datagen.flow(images_train, emotion_train, BATCH)
data_test = test_datagen.flow(images_test, emotion_test, BATCH)
# Generamos estructura secuencial, (capas apiladas)
CNN_model = Sequential()
# Capa convolucional 1
CNN_model.add(
Conv2D(NUM_CONV1,
kernel_size=TAM_FILTER,
activation='relu',
input_shape=np.shape(images_train[0])))
# Capa convolucional 2
CNN_model.add(Conv2D(NUM_CONV2, kernel_size=TAM_FILTER, activation='relu'))
CNN_model.add(MaxPooling2D(pool_size=(2, 2)))
# Capa convolucional 3
CNN_model.add(Conv2D(NUM_CONV3, kernel_size=TAM_FILTER, activation='relu'))
CNN_model.add(MaxPooling2D(pool_size=(2, 2)))
# Capa convolucional 4
CNN_model.add(Conv2D(NUM_CONV4, kernel_size=TAM_FILTER, activation='relu'))
CNN_model.add(MaxPooling2D(pool_size=(2, 2)))
# Aplanamiento de los datos
CNN_model.add(Flatten())
# RED NEURONAL MULTICAPA
# Capa 1
CNN_model.add(Dense(2048, activation='relu'))
CNN_model.add(Dropout(0.5))
# Capa 2
CNN_model.add(Dense(1024, activation='relu'))
CNN_model.add(Dropout(0.5))
# Capa output
CNN_model.add(Dense(NUM_CLASSES, activation='softmax'))
CNN_model.compile(loss='categorical_crossentropy',
optimizer=Adamax(lr=LEARNING_RATE, decay=DECAY),
metrics=['accuracy'])
# Gráficos a tiempo real
# Se define tensorboard para seguir el entrenamiento e tiempo real
tensorboard = tf.keras.callbacks.TensorBoard(log_dir=LOG_DIR)
try:
# Lanzamos los tensorboard
process = subprocess.Popen('tensorboard --logdir=./logs',
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
# Abrimos el navegador
os.system('start chrome http://localhost:6006/')
except Exception:
print("No pudo lanzarse tensorboard. Excepción: \n",
traceback.print_exc())
# CALLBACKS
checkpoint_name = 'val_acc_{val_accuracy:.4f}-{epoch:02d}.hdf5'
checkpoint_filepath = CKPT_DIR + checkpoint_name
csv_logger = tf.keras.callbacks.CSVLogger(LOG_CSV, append=False)
# early_stop = tf.keras.callbacks.EarlyStopping('val_loss', patience=PATIENCE)
model_checkpoint = tf.keras.callbacks.ModelCheckpoint(
checkpoint_filepath,
monitor='val_accuracy',
verbose=1,
mode='max',
save_best_only=True)
callbacks = [myCallback(), tensorboard, model_checkpoint, csv_logger]
# ENTRENAMIENTO
model_info = CNN_model.fit(data_train,
batch_size=BATCH,
epochs=EPOCH,
validation_data=data_test,
verbose=1,
callbacks=callbacks)
# EVALUACIÓN
results = CNN_model.evaluate(images_test, emotion_test, batch_size=128)
# GUARDADO DE LA ESTRUCTURA Y CONFIGURACIÓN EN UN .txt
file = open(SESSION_PATH + "info_model.txt", "w")
CNN_model.summary(print_fn=lambda x: file.write(x + '\n'))
file.write("\n\n" + "Learning rate: " + str(LEARNING_RATE) + "\nDecay: " +
str(DECAY))
file.close()
# CREACIÓN DE LA MATRIZ DE CONFUSIÓN
emotions = {
0: 'Enfado',
1: 'Asco',
2: 'Miedo',
3: 'Felicidad',
4: 'Tristeza',
5: 'Sorpresa',
6: 'Neutral'
}
predictions = CNN_model.predict(images_test)
predictions = np.argmax(predictions, axis=1)
emotions_true = np.argmax(emotion_test, axis=1)
conf_mat = metrics.confusion_matrix(y_true=emotions_true,
y_pred=predictions)
fig, ax = plot_confusion_matrix(conf_mat=conf_mat,
show_normed=True,
show_absolute=False,
class_names=emotions.values(),
figsize=(8, 8))
matrix_name = "MATRIZ_test_images"
# GUARDADO DEL MODELO Y FIGURA
accuracy = model_info.history['accuracy']
epochs = str(len(accuracy))
a = round(results[1], 3)
accuracy_value = str(a)
model_name = "model_e_" + epochs + "-acc_" + accuracy_value + ".hdf5"
try:
fig.savefig(SESSION_PATH + matrix_name)
CNN_model.save(SESSION_PATH + model_name)
except Exception:
print("Error al guardar el modelo \n", traceback.print_exc())
Testlabels.pop(0)
Liste_Testlabels = Testlabels
Testlabels = np.asarray(Testlabels)
Testbilder = np.asarray([Testbilder])
Testbilder = Testbilder.reshape(-1, 32, 32, 3)
Testbilder = np.asarray(Testbilder, dtype="float32")
Testlabels = np.asarray(Testlabels, dtype="float32")
model = load_model('model_99,105%.hdf5')
best = 0.99105305
batch_size1 = 64
batch_size2 = 64
batch_size3 = 128
opt = Adamax(lr=0.0004)
for a in range(10):
for i in range(150):
model.compile(loss='sparse_categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
if i < 50:
model.fit(Trainingsbilder,
Trainingslabels,
epochs=1,
shuffle=True,
batch_size=batch_size1)
with strategy.scope():
cmsnet = CMSNet(dl_input_shape=(None, height_crop, width_crop,
channels),
num_classes=n_classes,
output_stride=output_stride,
pooling=pooling,
residual_shortcut=residual_shortcut)
cmsnet.summary()
#cmsnet.mySummary()
# optimizer = SGD(momentum=0.9, nesterov=True)
#optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-6)
#optimizer = Adadelta(lr=0.008, rho=0.95, epsilon=None, decay=0.0)
optimizer = Adamax(lr=0.002,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0)
#optimizer = Nadam(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=None, schedule_decay=0.004)
miou = MIoU(num_classes=n_classes)
cmsnet.compile(loss='sparse_categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy', miou],
sample_weight_mode="temporal")
else:
cmsnet = CMSNet(dl_input_shape=(None, height_crop, width_crop, channels),
num_classes=n_classes,
output_stride=output_stride,
pooling=pooling,
residual_shortcut=residual_shortcut)
if not os.path.isfile(os.path.join(aux_exp_dir, "metrics.csv")):
if os.path.isdir(aux_exp_dir):
shutil.rmtree(aux_exp_dir)
if os.path.isdir(aux_tensorboard_dir):
shutil.rmtree(aux_tensorboard_dir)
train_df, val_df, _ = get_train_val_test_dfs(bboxs_csv, splits_csv)
train_datagen = BBoxsGenerator(train_df, imgs_dir=imgs_dir, out_image_size=(img_size, img_size), resize=(img_size!=224))
val_datagen = BBoxsGenerator(val_df, imgs_dir=imgs_dir, out_image_size=(img_size, img_size), resize=(img_size!=224))
del train_df, val_df
gc.collect()
model = build_bbox_model(input_size=(img_size, img_size, 3),
n_conv_blocks=n_conv_blocks, base_conv_n_filters=base_conv_n_filters,
n_dense_layers=2, dense_size=dense_size, dropout_rate=0.30,
loss=MeanSquaredError(), optimizer=Adamax(),
metrics=[MeanAbsoluteError(), MeanBBoxIoU(x2y2=True)])
run_experiment(model, exp_name, train_datagen, val_datagen,
results_dir=results_dir, tensorboard_logdir=tensorboard_dir,
generator_queue_size=50, generator_workers=8, use_multiprocessing=False)
del train_datagen, val_datagen, model
gc.collect()
tf.keras.backend.clear_session()
gc.collect()
### Temporary ###
sys.exit(0)
###########
for j in range(0, len(test_labels)):
labels.append(list(test_labels[j]).index(1))
predictions.append(result_fix[j].index(1))
# store confusion matrix
with open(result_folder + '/' + model_name + '_cm_' + str(num_classes),
'wb') as file_pi:
pickle.dump(confusion_matrix(labels, predictions), file_pi)
del model, history, predictions, labels, result, test_labels, result_fix
optimizers = {
'sgd': SGD(lr=0.001, momentum=0.9),
'adam': Adam(),
'adamax': Adamax(),
'adadelta': Adadelta(),
'adagrad': Adagrad(),
'ftrl': Ftrl(),
'nadam': Nadam(),
'rmsprop': RMSprop()
}
initializers = [
'constant', 'glorot_normal', 'glorot_uniform', 'he_normal', 'he_uniform',
'lecun_normal', 'lecun_uniform', 'random_normal', 'truncated_normal'
]
# Try lots of different small models, see what works best
fit_evaluate_model(mymodels.get_simple_cnn(IMG_DIM, num_classes), 'mymodel',
'baseline')
# CIFAR-10をデータセット化し，Train, Validation, Testに分割
ds_train = tf.data.Dataset.from_tensor_slices(
(x_train, y_train)).shuffle(x_train.shape[0]).batch(BATCH_SIZE_T)
ds_val = tf.data.Dataset.from_tensor_slices(
(x_val, y_val)).shuffle(x_val.shape[0]).batch(BATCH_SIZE_T)
ds_test = tf.data.Dataset.from_tensor_slices(
(x_test, y_test)).shuffle(x_test.shape[0]).batch(BATCH_SIZE_T)
ds = tf.data.Dataset.zip((ds_train, ds_val))
# Teacherモデルの定義
inputs = Input(shape=input_shape)
teacher = KDModel.Teacher(NUM_CLASSES)
teacher_model = teacher.createModel(inputs)
# Teacherモデルの学習
optimizer = Adamax(learning_rate=LR_T) # 最適化アルゴリズム
history_teacher = LossAccHistory()
training = KDModel.NormalTraining(teacher_model)
teacher_model.summary()
# plot_model(teacher_model, show_shapes=True, to_file='teacher_model.png')
for epoch in range(1, EPOCHS_T + 1):
loss_metric = Mean()
loss_metric_val = Mean()
acc_metric = Mean()
acc_metric_val = Mean()
acc = CategoricalAccuracy()
acc_val = CategoricalAccuracy()
# 各バッチごとに学習
for (x_train_, y_train_), (x_val_, y_val_) in ds:
loss_value, grads = training.grad(x_train_, y_train_)