def loopAllParticles(self, particles):
'''
THIS FUNCTION APPLIES PARTICLES ITERATION, EXECUTION CNN MODEL
:param particles: numpy array of shape (nParticles, dimensions)
:return: list: all losses returned along all particles iteration
'''
try:
losses = []
for i in range(particles.shape[0]):
config_func.print_log_message()
if isinstance(self.model, DenseNet.DenseNet) == True:
int_converted_values = [math.trunc(j) for j in particles[i][:-2]]
int_converted_values.append(particles[i][-2]) # compression rate --> float
int_converted_values.append(math.trunc(particles[i][-1]))
else:
int_converted_values = [math.trunc(i) for i in particles[i]] # CONVERSION OF DIMENSION VALUES OF PARTICLE
print(int_converted_values)
model, predictions, history = self.model.template_method(*int_converted_values) #APPLY BUILD, TRAIN AND PREDICT MODEL OPERATIONS, FOR EACH PARTICLE AND ITERATION
decoded_predictions = config_func.decode_array(predictions)
decoded_y_true = config_func.decode_array(self.model.data.y_test)
report, conf = config_func.getConfusionMatrix(decoded_predictions, decoded_y_true, dict=True)
acc = report['accuracy']# i can't compare y_test and predict, because some classes may have been unclassified
# define args to pass to objective function
obj_args = (model, report)
losses.append(self.objectiveFunction(acc, *obj_args)) #ADD COST LOSS TO LIST
K.clear_session()
gc.collect()
del model
return losses
except:
raise CustomError.ErrorCreationModel(config.ERROR_ON_OPTIMIZATION)
def train(self, model: Sequential, *args) -> Tuple[History, Sequential]:
'''
THIS FUNCTION IS RESPONSIBLE FOR MAKE THE TRAINING OF MODEL
:param model: Sequential model builded before, or passed (already trained model)
:return: Sequential model --> trained model
:return: History.history --> train and validation loss and metrics variation along epochs
'''
try:
if model is None:
raise CustomError.ErrorCreationModel(config.ERROR_NO_MODEL)
# OPTIMIZER
opt = Adam(learning_rate=config.LEARNING_RATE, decay=config.DECAY)
# COMPILE
model.compile(optimizer=opt,
loss=config.LOSS_CATEGORICAL,
metrics=[config.ACCURACY_METRIC])
#GET STRATEGIES RETURN DATA, AND IF DATA_AUGMENTATION IS APPLIED TRAIN GENERATOR
train_generator = None
# get data
X_train = self.data.X_train
y_train = self.data.y_train
if self.StrategyList: # if strategylist is not empty
for i, j in zip(self.StrategyList,
range(len(self.StrategyList))):
if isinstance(i, DataAugmentation.DataAugmentation):
train_generator = self.StrategyList[j].applyStrategy(
self.data)
if isinstance(i, OverSampling.OverSampling):
X_train, y_train = self.StrategyList[j].applyStrategy(
self.data)
if isinstance(i, UnderSampling.UnderSampling):
X_train, y_train = self.StrategyList[j].applyStrategy(
self.data)
#reduce_lr = LearningRateScheduler(config_func.lr_scheduler)
es_callback = EarlyStopping(monitor='val_loss',
patience=5,
restore_best_weights=True)
decrease_callback = ReduceLROnPlateau(monitor='val_loss',
patience=1,
factor=0.7,
mode='min',
verbose=0,
min_lr=0.000001)
decrease_callback2 = ReduceLROnPlateau(monitor='loss',
patience=1,
factor=0.7,
mode='min',
verbose=0,
min_lr=0.000001)
weights_y_train = config_func.decode_array(y_train)
class_weights = class_weight.compute_class_weight(
'balanced', np.unique(weights_y_train), weights_y_train)
if train_generator is None: #NO DATA AUGMENTATION
history = model.fit(
x=X_train,
y=y_train,
batch_size=args[0],
epochs=config.EPOCHS,
validation_data=(self.data.X_val, self.data.y_val),
shuffle=True,
#use_multiprocessing=config.MULTIPROCESSING,
callbacks=[
decrease_callback2, es_callback, decrease_callback
],
class_weight=class_weights,
verbose=config.TRAIN_VERBOSE)
return history, model
#ELSE APPLY DATA AUGMENTATION
history = model.fit_generator(
generator=train_generator,
validation_data=(self.data.X_val, self.data.y_val),
epochs=config.EPOCHS,
steps_per_epoch=X_train.shape[0] / args[0],
shuffle=True,
callbacks=[decrease_callback2, es_callback, decrease_callback],
verbose=config.TRAIN_VERBOSE,
class_weight=class_weights)
return history, model
except:
raise CustomError.ErrorCreationModel(config.ERROR_ON_TRAINING)
def train(self, model : Sequential, *args) -> Tuple[History, Sequential]:
try:
if model is None:
raise CustomError.ErrorCreationModel(config.ERROR_NO_MODEL)
# OPTIMIZER
opt = Adam(learning_rate=config.LEARNING_RATE, decay=config.DECAY)
#opt = SGD(learning_rate=0.001, decay=config.DECAY, momentum=0.9, nesterov=True)
# COMPILE
model.compile(optimizer=opt, loss=config.LOSS_CATEGORICAL, metrics=[config.ACCURACY_METRIC])
#GET STRATEGIES RETURN DATA, AND IF DATA_AUGMENTATION IS APPLIED TRAIN GENERATOR
train_generator = None
# get data
X_train = self.data.X_train
y_train = self.data.y_train
if self.StrategyList: # if strategylist is not empty
for i, j in zip(self.StrategyList, range(len(self.StrategyList))):
if isinstance(i, DataAugmentation.DataAugmentation):
train_generator = self.StrategyList[j].applyStrategy(self.data)
if isinstance(i, OverSampling.OverSampling):
X_train, y_train = self.StrategyList[j].applyStrategy(self.data)
if isinstance(i, UnderSampling.UnderSampling):
X_train, y_train = self.StrategyList[j].applyStrategy(self.data)
es_callback = EarlyStopping(monitor='val_loss', patience=2)
decrease_callback = ReduceLROnPlateau(monitor='loss',
patience=1,
factor=0.7,
mode='min',
verbose=1,
min_lr=0.000001)
decrease_callback2 = ReduceLROnPlateau(monitor='val_loss',
patience=1,
factor=0.7,
mode='min',
verbose=1,
min_lr=0.000001)
#CLASS WEIGHTS
weights_y_train = config_func.decode_array(y_train)
class_weights = class_weight.compute_class_weight('balanced',
numpy.unique(weights_y_train),
weights_y_train)
if train_generator is None: #NO DATA AUGMENTATION
history = model.fit(
x=X_train,
y=y_train,
batch_size=args[0],
epochs=config.EPOCHS,
validation_data=(self.data.X_val, self.data.y_val),
shuffle=True,
callbacks=[es_callback, decrease_callback, decrease_callback2],
verbose=config.TRAIN_VERBOSE,
class_weight=class_weights
)
return history, model
#ELSE APPLY DATA AUGMENTATION
history = model.fit_generator(
generator=train_generator,
validation_data=(self.data.X_val, self.data.y_val),
epochs=config.EPOCHS,
steps_per_epoch=X_train.shape[0] / args[0],
shuffle=True,
class_weight=class_weights,
verbose=config.TRAIN_VERBOSE,
callbacks= [es_callback, decrease_callback, decrease_callback2]
)
return history, model
except:
raise CustomError.ErrorCreationModel(config.ERROR_ON_TRAINING)