def queryUncertainInstances(self, drop_instances, num_instances):
if num_instances == 0:
return []
queries_df = self.getSelectedInstancesDataframe(drop_instances)
matrix_tools.sortDataFrame(queries_df, 'entropy', False, True)
queries_df = queries_df.head(num_instances)
self.addAnnotationQueries('uncertain', 'low', queries_df)
return map(int, queries_df.index.values.tolist())
def queryLowLikelihoodInstances(self, drop_instances, num_instances):
if num_instances == 0:
return []
queries_df = self.getSelectedInstancesDataframe(drop_instances)
matrix_tools.sortDataFrame(queries_df, 'likelihood', True, True)
queries_df = queries_df.head(num_instances)
self.addAnnotationQueries('low_likelihood', 'low', queries_df)
return map(int, queries_df.index.values.tolist())
def generateFamiliesScoresTables(self, classifier = None):
if classifier is None:
families_scores = {}
families_scores['lr'] = self.generateFamiliesScoresTables('lr')
families_scores['nb'] = self.generateFamiliesScoresTables('nb')
return families_scores
families_scores = []
for i, family in enumerate(list(self.lr_class_labels)):
family_scores = self.scores.loc[self.scores[classifier + '_prediction'] == family]
matrix_tools.sortDataFrame(family_scores, classifier + '_score', True, True)
families_scores.append(family_scores)
return families_scores
def generateAnnotationQueries(self):
predicted_scores = self.predictions['scores']
boundary_scores = abs(predicted_scores) / max(abs(predicted_scores))
neighbours_scores = self.computeNeighboursScores()
global_scores = self.delta * boundary_scores + (
1 - self.delta) * neighbours_scores
queries_df = pd.DataFrame(data={
'scores': predicted_scores,
'boundary_scores': boundary_scores,
'neighbours_scores': neighbours_scores,
'global_scores': global_scores
},
index=self.predictions.index)
matrix_tools.sortDataFrame(queries_df, 'global_scores', True, True)
queries_df = queries_df.head(n=self.num_annotations)
for index, row in queries_df.iterrows():
query = AnnotationQuery(index, row['scores'], None, None)
self.annotation_queries.append(query)
def generateAlertsCsvFile(self, directory):
detection_threshold = self.alerts_conf.detection_threshold
with open(directory + 'alerts.csv', 'w') as f:
alerts = matrix_tools.extractRowsWithThresholds(
self.predictions_monitoring.predictions, detection_threshold,
None, 'predicted_proba')
alerts = matrix_tools.sortDataFrame(alerts, 'predicted_proba',
False, False)
alerts.to_csv(f, index_label='instance_id')
return list(alerts.index.values)
def getFamiliesBarplot(project, dataset, experiment_id, iteration, label):
experiment = ExperimentFactory.getFactory().fromJson(
project, dataset, experiment_id, db, cursor)
experiment_label_id = experiment.experiment_label_id
if iteration == 'None':
iteration = None
family_counts = labels_tools.getFamiliesCounts(cursor,
experiment_label_id,
iteration_max=iteration,
label=label)
df = pd.DataFrame({
'families':
family_counts.keys(),
'counts': [family_counts[k] for k in family_counts.keys()]
})
matrix_tools.sortDataFrame(df, 'families', ascending=True, inplace=True)
barplot = BarPlot(list(df['families']))
barplot.addDataset(list(df['counts']), colors_tools.getLabelColor(label),
'Num. Instances')
return jsonify(barplot.barplot)
def getFamiliesBarplot(experiment_id, iteration, label):
experiment = updateCurrentExperiment(experiment_id)
experiment_label_id = experiment.labels_id
if iteration == 'None':
iteration = None
family_counts = labels_tools.getFamiliesCounts(experiment.session,
experiment_label_id,
iteration_max=iteration,
label=label)
df = pd.DataFrame({
'families':
family_counts.keys(),
'counts': [family_counts[k] for k in family_counts.keys()]
})
matrix_tools.sortDataFrame(df, 'families', ascending=True, inplace=True)
barplot = BarPlot(list(df['families']))
dataset = PlotDataset(list(df['counts']), 'Num. Instances')
dataset.setColor(colors_tools.getLabelColor(label))
barplot.addDataset(dataset)
return jsonify(barplot.toJson())
def finalComputations(self):
matrix_tools.sortDataFrame(self.predictions, 'predicted_proba', True,
True)
def generateQueriesFromScores(self):
assert (np.array_equal(self.lr_class_labels, self.nb_class_labels))
lr_predicted_proba_df = self.generateLrPredictedProbaDataFrame()
num_families = len(self.lr_class_labels)
self.annotation_queries = []
# There are fewer annotation queries than the number of families
if self.num_annotations <= num_families:
if self.iteration.iteration_number % 2 == 0:
classifier = 'lr'
else:
classifier = 'nb'
matrix_tools.sortDataFrame(self.scores, classifier + '_score',
True, True)
selected_instances = self.scores.index.tolist()[:self.
num_annotations]
for instance_id in selected_instances:
query = AnnotationQuery(instance_id, 0, None, None)
self.annotation_queries.append(query)
return
# Otherwise
num_uncertain = [0] * num_families
num_anomalous = [0] * num_families
families_scores = self.generateFamiliesScoresTables()
num_annotations = 0
stop = False
selected_instances = []
while not stop:
for i, family in enumerate(list(self.lr_class_labels)):
if num_uncertain[i] <= num_anomalous[i]:
classifier = 'lr'
num_uncertain[i] += 1
else:
classifier = 'nb'
num_anomalous[i] += 1
scores = families_scores[classifier][i]
selected_rows = scores.loc[scores['queried'] == False]
if len(selected_rows) > 0:
query = selected_rows.index.tolist()[0]
else:
# No anomalous or uncertain instances available for annotation
# Select the most likely instance according to the logistic regression output
print family + ': no anomalous, no uncertain instances'
selected_rows = lr_predicted_proba_df.loc[
lr_predicted_proba_df['queried'] == False]
matrix_tools.sortDataFrame(selected_rows, family, False,
True)
query = selected_rows.index.tolist()[0]
# Add annotation query and set queried = True
num_annotations += 1
selected_instances.append(query)
for c in ['nb', 'lr']:
predicted_class = self.scores.loc[query, c + '_prediction']
predicted_class_index = np.where(
self.lr_class_labels == predicted_class)[0]
families_scores[c][predicted_class_index].set_value(
query, 'queried', True)
self.scores.set_value(query, 'queried', True)
lr_predicted_proba_df.set_value(query, 'queried', True)
# Break condition
if num_annotations >= self.num_annotations:
stop = True
break
for instance_id in selected_instances:
query = AnnotationQuery(instance_id, 0, None, None)
self.annotation_queries.append(query)
def sortInstances(self):
df = pd.DataFrame({'distance': self.distances},
index=map(str, self.instances_ids))
matrix_tools.sortDataFrame(df, 'distance', True, True)
self.instances_ids = map(int, df.index.values.tolist())
self.distances = df.distance.tolist()
def display(self, directory):
with open(directory + 'model_coefficients.csv', 'w') as f:
matrix_tools.sortDataFrame(self.coef_summary, 'abs_mean', False,
True)
self.coef_summary.to_csv(f, index_label='feature')
