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')