@Override
public void processNewResult(ResultHierarchy hier, Result newResult) {
// We may just have added this result.
if (newResult instanceof Clustering && isReferenceResult((Clustering<?>) newResult)) {
return;
}
Database db = ResultUtil.findDatabase(hier);
List<Clustering<?>> crs = ResultUtil.getClusteringResults(newResult);
if (crs == null || crs.size() < 1) {
return;
}
// Compute the reference clustering
Clustering<?> refc = null;
// Try to find an existing reference clustering (globally)
{
Collection<Clustering<?>> cs = ResultUtil.filterResults(hier, db, Clustering.class);
for (Clustering<?> test : cs) {
if (isReferenceResult(test)) {
refc = test;
break;
}
}
}
// Try to find an existing reference clustering (locally)
if (refc == null) {
Collection<Clustering<?>> cs = ResultUtil.filterResults(hier, newResult, Clustering.class);
for (Clustering<?> test : cs) {
if (isReferenceResult(test)) {
refc = test;
break;
}
}
}
if (refc == null) {
LOG.debug("Generating a new reference clustering.");
Result refres = referencealg.run(db);
List<Clustering<?>> refcrs = ResultUtil.getClusteringResults(refres);
if (refcrs.size() == 0) {
LOG.warning("Reference algorithm did not return a clustering result!");
return;
}
if (refcrs.size() > 1) {
LOG.warning("Reference algorithm returned more than one result!");
}
refc = refcrs.get(0);
} else {
LOG.debug("Using existing clustering: " + refc.getLongName() + " " + refc.getShortName());
}
for (Clustering<?> c : crs) {
if (c == refc) {
continue;
}
evaluteResult(db, c, refc);
}
}
@Override
public void processNewResult(ResultHierarchy hier, Result result) {
List<Clustering<?>> crs = ResultUtil.getClusteringResults(result);
if (crs.size() < 1) {
return;
}
Database db = ResultUtil.findDatabase(hier);
Relation<? extends NumberVector> rel = db.getRelation(this.distance.getInputTypeRestriction());
for (Clustering<?> c : crs) {
evaluateClustering(db, rel, c);
}
}
@Override
public void processNewResult(ResultHierarchy hier, Result result) {
List<Clustering<?>> crs = ResultUtil.getClusteringResults(result);
if (crs.size() < 1) {
return;
}
Database db = ResultUtil.findDatabase(hier);
Relation<O> rel = db.getRelation(distance.getInputTypeRestriction());
DistanceQuery<O> dq = db.getDistanceQuery(rel, distance);
for (Clustering<?> c : crs) {
evaluateClustering(db, rel, dq, c);
}
}
@Override
public void processNewResult(HierarchicalResult baseResult, Result result) {
final Database db = ResultUtil.findDatabase(baseResult);
List<OutlierResult> ors = ResultUtil.filterResults(result, OutlierResult.class);
if (ors == null || ors.size() <= 0) {
// logger.warning("No outlier results found for
// "+ComputeOutlierHistogram.class.getSimpleName());
return;
}
for (OutlierResult or : ors) {
db.getHierarchy().add(or, evaluateOutlierResult(db, or));
}
}
protected void autoEvaluateClusterings(ResultHierarchy hier, Result newResult) {
Collection<Clustering<?>> clusterings =
ResultUtil.filterResults(hier, newResult, Clustering.class);
if (LOG.isDebugging()) {
LOG.warning("Number of new clustering results: " + clusterings.size());
}
for (Iterator<Clustering<?>> c = clusterings.iterator(); c.hasNext(); ) {
Clustering<?> test = c.next();
if ("allinone-clustering".equals(test.getShortName())) {
c.remove();
} else if ("allinnoise-clustering".equals(test.getShortName())) {
c.remove();
} else if ("bylabel-clustering".equals(test.getShortName())) {
c.remove();
} else if ("bymodel-clustering".equals(test.getShortName())) {
c.remove();
}
}
if (clusterings.size() > 0) {
try {
new EvaluateClustering(new ByLabelClustering(), false, true)
.processNewResult(hier, newResult);
} catch (NoSupportedDataTypeException e) {
// Pass - the data probably did not have labels.
}
}
}
protected void autoEvaluateOutliers(ResultHierarchy hier, Result newResult) {
Collection<OutlierResult> outliers =
ResultUtil.filterResults(hier, newResult, OutlierResult.class);
if (LOG.isDebugging()) {
LOG.debug("Number of new outlier results: " + outliers.size());
}
if (outliers.size() > 0) {
Database db = ResultUtil.findDatabase(hier);
ResultUtil.ensureClusteringResult(db, db);
Collection<Clustering<?>> clusterings = ResultUtil.filterResults(hier, db, Clustering.class);
if (clusterings.size() == 0) {
LOG.warning(
"Could not find a clustering result, even after running 'ensureClusteringResult'?!?");
return;
}
Clustering<?> basec = clusterings.iterator().next();
// Find minority class label
int min = Integer.MAX_VALUE;
int total = 0;
String label = null;
if (basec.getAllClusters().size() > 1) {
for (Cluster<?> c : basec.getAllClusters()) {
final int csize = c.getIDs().size();
total += csize;
if (csize < min) {
min = csize;
label = c.getName();
}
}
}
if (label == null) {
LOG.warning("Could not evaluate outlier results, as I could not find a minority label.");
return;
}
if (min == 1) {
LOG.warning(
"The minority class label had a single object. Try using 'ClassLabelFilter' to identify the class label column.");
}
if (min > 0.05 * total) {
LOG.warning(
"The minority class I discovered (labeled '"
+ label
+ "') has "
+ (min * 100. / total)
+ "% of objects. Outlier classes should be more rare!");
}
LOG.verbose("Evaluating using minority class: " + label);
Pattern pat = Pattern.compile("^" + Pattern.quote(label) + "$");
// Evaluate rankings.
new OutlierRankingEvaluation(pat).processNewResult(hier, newResult);
// Compute ROC curve
new OutlierROCCurve(pat).processNewResult(hier, newResult);
// Compute Precision at k
new OutlierPrecisionAtKCurve(pat, min << 1).processNewResult(hier, newResult);
// Compute ROC curve
new OutlierPrecisionRecallCurve(pat).processNewResult(hier, newResult);
// Compute outlier histogram
new ComputeOutlierHistogram(pat, 50, new LinearScaling(), false)
.processNewResult(hier, newResult);
}
}
