def registerModelData(self, train_ret, test_ret, lowest_error_epoch=False):
"""
This method updates stats about the model, it's called on each epoch
Stores:
- loss
- error
- confusion matrices
:param train_ret The result of training a batch
:param test_ret The result of testing after an epoch
:param lowest_error_epoch Is this epoch the one with the lowest error so far
"""
# Operations that happen regardless of it being or not a lowest error epoch or not
self.ml_model_info.loss_y += [train_ret.loss]
self.ml_model_info.loss_x += [train_ret.epoch]
self.ml_model_info.error_y += [test_ret.error]
self.ml_model_info.error_x += [train_ret.epoch]
if lowest_error_epoch == True:
# denorm the real and predicted
predicted_targets = {}
real_targets = {}
for col in test_ret.predicted_targets:
predicted_targets[col] = [
denorm(row,
self.persistent_model_metadata.column_stats[col])
for row in test_ret.predicted_targets[col]
]
real_targets[col] = [
denorm(row,
self.persistent_model_metadata.column_stats[col])
for row in test_ret.real_targets[col]
]
self.ml_model_info.confussion_matrices = self.calculateConfusionMatrices(
real_targets, predicted_targets)
self.ml_model_info.lowest_error = test_ret.error
self.ml_model_info.predicted_targets = predicted_targets
self.ml_model_info.real_targets = real_targets
self.ml_model_info.accuracy = test_ret.accuracy
self.ml_model_info.r_squared = test_ret.accuracy
self.ml_model_info.update()
return True
def predict(self, data=None):
"""
This actually calls the model and returns the predictions in diff form
:return: diffs, which is a list of dictionaries with pointers as to where to replace the prediction given the value that was predicted
"""
if data != None:
self._loadData(data)
self.predict_sampler.variable_wrapper = self.ml_model_class.variable_wrapper
self.predict_sampler.variable_unwrapper = self.ml_model_class.variable_unwrapper
ret_diffs = []
for batch in self.predict_sampler:
logging.info('predicting batch...')
if self.data_model_object.use_full_text_input:
ret = self.data_model_object.forward(
batch.getInput(flatten=self.data_model_object.flatInput),
full_text_input=batch.getFullTextInput())
else:
ret = self.data_model_object.forward(
batch.getInput(flatten=self.data_model_object.flatInput))
if type(ret) != type({}):
ret_dict = batch.deflatTarget(ret)
else:
ret_dict = ret
ret_dict_denorm = {}
for col in ret_dict:
ret_dict[col] = self.ml_model_class.variable_unwrapper(
ret_dict[col])
for row in ret_dict[col]:
if col not in ret_dict_denorm:
ret_dict_denorm[col] = []
ret_dict_denorm[col] += [
denorm(
row,
self.persistent_model_metadata.column_stats[col])
]
ret_total_item = {
'group_pointer': batch.group_pointer,
'column_pointer': batch.column_pointer,
'start_pointer': batch.start_pointer,
'end_pointer': batch.end_pointer,
'ret_dict': ret_dict_denorm
}
ret_diffs += [ret_total_item]
return ret_diffs
def run(self):
result = []
#NOTE: we only use this model in PREDICT
for group in self.transaction.model_data.predict_set:
for column in self.transaction.model_data.predict_set[group]:
column_results = []
for value in self.transaction.model_data.predict_set[group][column]:
stats = self.transaction.model_stats[column]
denormed = denorm(value=value, cell_stats=stats)
column_results.append(denormed)
result.append(column_results)
# Why transponse?
#result = numpy.transpose(result)
#result = result.tolist()
return result