Examples with NeighborSetPredicate de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate used on opensource projects

Example 6 with NeighborSetPredicate

use of de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate in project elki by elki-project.

the class TrimmedMeanApproach method run.

/**
 * Run the algorithm.
 *
 * @param database Database
 * @param nrel Neighborhood relation
 * @param relation Data Relation (1 dimensional!)
 * @return Outlier detection result
 */
public OutlierResult run(Database database, Relation<N> nrel, Relation<? extends NumberVector> relation) {
    assert (RelationUtil.dimensionality(relation) == 1) : "TrimmedMean can only process one-dimensional data sets.";
    final NeighborSetPredicate npred = getNeighborSetPredicateFactory().instantiate(database, nrel);
    WritableDoubleDataStore errors = DataStoreUtil.makeDoubleStorage(relation.getDBIDs(), DataStoreFactory.HINT_TEMP);
    WritableDoubleDataStore scores = DataStoreUtil.makeDoubleStorage(relation.getDBIDs(), DataStoreFactory.HINT_STATIC);
    FiniteProgress progress = LOG.isVerbose() ? new FiniteProgress("Computing trimmed means", relation.size(), LOG) : null;
    for (DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
        DBIDs neighbors = npred.getNeighborDBIDs(iditer);
        int num = 0;
        double[] values = new double[neighbors.size()];
        // calculate trimmedMean
        for (DBIDIter iter = neighbors.iter(); iter.valid(); iter.advance()) {
            values[num] = relation.get(iter).doubleValue(0);
            num++;
        }
        // calculate local trimmed Mean and error term
        final double tm;
        if (num > 0) {
            int left = (int) Math.floor(p * (num - 1));
            int right = (int) Math.floor((1 - p) * (num - 1));
            Arrays.sort(values, 0, num);
            Mean mean = new Mean();
            for (int i = left; i <= right; i++) {
                mean.put(values[i]);
            }
            tm = mean.getMean();
        } else {
            tm = relation.get(iditer).doubleValue(0);
        }
        // Error: deviation from trimmed mean
        errors.putDouble(iditer, relation.get(iditer).doubleValue(0) - tm);
        LOG.incrementProcessed(progress);
    }
    LOG.ensureCompleted(progress);
    if (LOG.isVerbose()) {
        LOG.verbose("Computing median error.");
    }
    double median_dev_from_median;
    {
        // calculate the median error
        double[] ei = new double[relation.size()];
        {
            int i = 0;
            for (DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
                ei[i] = errors.doubleValue(iditer);
                i++;
            }
        }
        double median_i = QuickSelect.median(ei);
        // Update to deviation from median
        for (int i = 0; i < ei.length; i++) {
            ei[i] = Math.abs(ei[i] - median_i);
        }
        // Again, extract median
        median_dev_from_median = QuickSelect.median(ei);
    }
    if (LOG.isVerbose()) {
        LOG.verbose("Normalizing scores.");
    }
    // calculate score
    DoubleMinMax minmax = new DoubleMinMax();
    for (DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
        double score = Math.abs(errors.doubleValue(iditer)) * 0.6745 / median_dev_from_median;
        scores.putDouble(iditer, score);
        minmax.put(score);
    }
    // 
    DoubleRelation scoreResult = new MaterializedDoubleRelation("TrimmedMean", "Trimmed Mean Score", scores, relation.getDBIDs());
    OutlierScoreMeta scoreMeta = new BasicOutlierScoreMeta(minmax.getMin(), minmax.getMax(), 0.0, Double.POSITIVE_INFINITY, 0);
    OutlierResult or = new OutlierResult(scoreMeta, scoreResult);
    or.addChildResult(npred);
    return or;
}

Example 7 with NeighborSetPredicate

use of de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate in project elki by elki-project.

the class SLOM method run.

/**
 * @param database Database to process
 * @param spatial Spatial Relation to use.
 * @param relation Relation to use.
 * @return Outlier detection result
 */
public OutlierResult run(Database database, Relation<N> spatial, Relation<O> relation) {
    final NeighborSetPredicate npred = getNeighborSetPredicateFactory().instantiate(database, spatial);
    DistanceQuery<O> distFunc = getNonSpatialDistanceFunction().instantiate(relation);
    WritableDoubleDataStore modifiedDistance = DataStoreUtil.makeDoubleStorage(relation.getDBIDs(), DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP);
    // calculate D-Tilde
    for (DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
        double sum = 0;
        double maxDist = 0;
        int cnt = 0;
        final DBIDs neighbors = npred.getNeighborDBIDs(iditer);
        for (DBIDIter iter = neighbors.iter(); iter.valid(); iter.advance()) {
            if (DBIDUtil.equal(iditer, iter)) {
                continue;
            }
            double dist = distFunc.distance(iditer, iter);
            sum += dist;
            cnt++;
            maxDist = Math.max(maxDist, dist);
        }
        if (cnt > 1) {
            modifiedDistance.putDouble(iditer, ((sum - maxDist) / (cnt - 1)));
        } else {
            // Use regular distance when the d-tilde trick is undefined.
            // Note: this can be 0 when there were no neighbors.
            modifiedDistance.putDouble(iditer, maxDist);
        }
    }
    // Second step - compute actual SLOM values
    DoubleMinMax slomminmax = new DoubleMinMax();
    WritableDoubleDataStore sloms = DataStoreUtil.makeDoubleStorage(relation.getDBIDs(), DataStoreFactory.HINT_STATIC);
    for (DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
        double sum = 0;
        int cnt = 0;
        final DBIDs neighbors = npred.getNeighborDBIDs(iditer);
        for (DBIDIter iter = neighbors.iter(); iter.valid(); iter.advance()) {
            if (DBIDUtil.equal(iditer, iter)) {
                continue;
            }
            sum += modifiedDistance.doubleValue(iter);
            cnt++;
        }
        double slom;
        if (cnt > 0) {
            // With and without the object itself:
            double avgPlus = (sum + modifiedDistance.doubleValue(iditer)) / (cnt + 1);
            double avg = sum / cnt;
            double beta = 0;
            for (DBIDIter iter = neighbors.iter(); iter.valid(); iter.advance()) {
                final double dist = modifiedDistance.doubleValue(iter);
                if (dist > avgPlus) {
                    beta += 1;
                } else if (dist < avgPlus) {
                    beta -= 1;
                }
            }
            // Include object itself
            if (!neighbors.contains(iditer)) {
                final double dist = modifiedDistance.doubleValue(iditer);
                if (dist > avgPlus) {
                    beta += 1;
                } else if (dist < avgPlus) {
                    beta -= 1;
                }
            }
            beta = Math.abs(beta);
            // note: cnt == size of N(x), not N+(x)
            if (cnt > 1) {
                beta = Math.max(beta, 1.0) / (cnt - 1);
            } else {
                // Workaround insufficiency in SLOM paper - div by zero
                beta = 1.0;
            }
            beta = beta / (1 + avg);
            slom = beta * modifiedDistance.doubleValue(iditer);
        } else {
            // No neighbors to compare to - no score.
            slom = 0.0;
        }
        sloms.putDouble(iditer, slom);
        slomminmax.put(slom);
    }
    DoubleRelation scoreResult = new MaterializedDoubleRelation("SLOM", "slom-outlier", sloms, relation.getDBIDs());
    OutlierScoreMeta scoreMeta = new BasicOutlierScoreMeta(slomminmax.getMin(), slomminmax.getMax(), 0.0, Double.POSITIVE_INFINITY);
    OutlierResult or = new OutlierResult(scoreMeta, scoreResult);
    or.addChildResult(npred);
    return or;
}

Example 8 with NeighborSetPredicate

use of de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate in project elki by elki-project.

the class CTLuMeanMultipleAttributes method run.

/**
 * Run the algorithm
 *
 * @param database Database
 * @param spatial Spatial relation
 * @param attributes Numerical attributes
 * @return Outlier detection result
 */
public OutlierResult run(Database database, Relation<N> spatial, Relation<O> attributes) {
    if (LOG.isDebugging()) {
        LOG.debug("Dimensionality: " + RelationUtil.dimensionality(attributes));
    }
    final NeighborSetPredicate npred = getNeighborSetPredicateFactory().instantiate(database, spatial);
    CovarianceMatrix covmaker = new CovarianceMatrix(RelationUtil.dimensionality(attributes));
    WritableDataStore<double[]> deltas = DataStoreUtil.makeStorage(attributes.getDBIDs(), DataStoreFactory.HINT_TEMP, double[].class);
    for (DBIDIter iditer = attributes.iterDBIDs(); iditer.valid(); iditer.advance()) {
        final O obj = attributes.get(iditer);
        final DBIDs neighbors = npred.getNeighborDBIDs(iditer);
        // TODO: remove object itself from neighbors?
        // Mean vector "g"
        double[] mean = Centroid.make(attributes, neighbors).getArrayRef();
        // Delta vector "h"
        double[] delta = minusEquals(obj.toArray(), mean);
        deltas.put(iditer, delta);
        covmaker.put(delta);
    }
    // Finalize covariance matrix:
    double[] mean = covmaker.getMeanVector();
    double[][] cmati = inverse(covmaker.destroyToSampleMatrix());
    DoubleMinMax minmax = new DoubleMinMax();
    WritableDoubleDataStore scores = DataStoreUtil.makeDoubleStorage(attributes.getDBIDs(), DataStoreFactory.HINT_STATIC);
    for (DBIDIter iditer = attributes.iterDBIDs(); iditer.valid(); iditer.advance()) {
        final double score = mahalanobisDistance(cmati, deltas.get(iditer), mean);
        minmax.put(score);
        scores.putDouble(iditer, score);
    }
    DoubleRelation scoreResult = new MaterializedDoubleRelation("mean multiple attributes spatial outlier", "mean-multipleattributes-outlier", scores, attributes.getDBIDs());
    OutlierScoreMeta scoreMeta = new BasicOutlierScoreMeta(minmax.getMin(), minmax.getMax(), 0.0, Double.POSITIVE_INFINITY, 0);
    OutlierResult or = new OutlierResult(scoreMeta, scoreResult);
    or.addChildResult(npred);
    return or;
}

Example 9 with NeighborSetPredicate

use of de.lmu.ifi.dbs.elki.algorithm.outlier.spatial.neighborhood.NeighborSetPredicate in project elki by elki-project.

the class SOF method run.

/**
 * The main run method
 *
 * @param database Database to use (actually unused)
 * @param spatial Relation for neighborhood
 * @param relation Attributes to evaluate
 * @return Outlier result
 */
public OutlierResult run(Database database, Relation<N> spatial, Relation<O> relation) {
    final NeighborSetPredicate npred = getNeighborSetPredicateFactory().instantiate(database, spatial);
    DistanceQuery<O> distFunc = getNonSpatialDistanceFunction().instantiate(relation);
    WritableDoubleDataStore lrds = DataStoreUtil.makeDoubleStorage(relation.getDBIDs(), DataStoreFactory.HINT_TEMP | DataStoreFactory.HINT_HOT);
    WritableDoubleDataStore lofs = DataStoreUtil.makeDoubleStorage(relation.getDBIDs(), DataStoreFactory.HINT_STATIC);
    DoubleMinMax lofminmax = new DoubleMinMax();
    // Compute densities
    for (DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
        DBIDs neighbors = npred.getNeighborDBIDs(iditer);
        double avg = 0;
        for (DBIDIter iter = neighbors.iter(); iter.valid(); iter.advance()) {
            avg += distFunc.distance(iditer, iter);
        }
        double lrd = 1 / (avg / neighbors.size());
        if (Double.isNaN(lrd)) {
            lrd = 0;
        }
        lrds.putDouble(iditer, lrd);
    }
    // Compute density quotients
    for (DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
        DBIDs neighbors = npred.getNeighborDBIDs(iditer);
        double avg = 0;
        for (DBIDIter iter = neighbors.iter(); iter.valid(); iter.advance()) {
            avg += lrds.doubleValue(iter);
        }
        final double lrd = (avg / neighbors.size()) / lrds.doubleValue(iditer);
        if (!Double.isNaN(lrd)) {
            lofs.putDouble(iditer, lrd);
            lofminmax.put(lrd);
        } else {
            lofs.putDouble(iditer, 0.0);
        }
    }
    // Build result representation.
    DoubleRelation scoreResult = new MaterializedDoubleRelation("Spatial Outlier Factor", "sof-outlier", lofs, relation.getDBIDs());
    OutlierScoreMeta scoreMeta = new QuotientOutlierScoreMeta(lofminmax.getMin(), lofminmax.getMax(), 0.0, Double.POSITIVE_INFINITY, 1.0);
    OutlierResult or = new OutlierResult(scoreMeta, scoreResult);
    or.addChildResult(npred);
    return or;
}