Java DistanceMeasure.compute方法代码示例

import org.apache.commons.math3.ml.distance.DistanceMeasure; //导入方法依赖的package包/类
/**
 * Finds the neuron that best matches the given features.
 *
 * @param features Data.
 * @param neurons List of neurons to scan. If the list is empty
 * {@code null} will be returned.
 * @param distance Distance function. The neuron's features are
 * passed as the first argument to {@link DistanceMeasure#compute(double[],double[])}.
 * @return the neuron whose features are closest to the given data.
 * @throws org.apache.commons.math3.exception.DimensionMismatchException
 * if the size of the input is not compatible with the neurons features
 * size.
 */
public static Neuron findBest(double[] features,
                              Iterable<Neuron> neurons,
                              DistanceMeasure distance) {
    Neuron best = null;
    double min = Double.POSITIVE_INFINITY;
    for (final Neuron n : neurons) {
        final double d = distance.compute(n.getFeatures(), features);
        if (d < min) {
            min = d;
            best = n;
        }
    }

    return best;
}
 

import org.apache.commons.math3.ml.distance.DistanceMeasure; //导入方法依赖的package包/类
/**
 * Finds the two neurons that best match the given features.
 *
 * @param features Data.
 * @param neurons List of neurons to scan. If the list is empty
 * {@code null} will be returned.
 * @param distance Distance function. The neuron's features are
 * passed as the first argument to {@link DistanceMeasure#compute(double[],double[])}.
 * @return the two neurons whose features are closest to the given data.
 * @throws org.apache.commons.math3.exception.DimensionMismatchException
 * if the size of the input is not compatible with the neurons features
 * size.
 */
public static Pair<Neuron, Neuron> findBestAndSecondBest(double[] features,
                                                         Iterable<Neuron> neurons,
                                                         DistanceMeasure distance) {
    Neuron[] best = { null, null };
    double[] min = { Double.POSITIVE_INFINITY,
                     Double.POSITIVE_INFINITY };
    for (final Neuron n : neurons) {
        final double d = distance.compute(n.getFeatures(), features);
        if (d < min[0]) {
            // Replace second best with old best.
            min[1] = min[0];
            best[1] = best[0];

            // Store current as new best.
            min[0] = d;
            best[0] = n;
        } else if (d < min[1]) {
            // Replace old second best with current.
            min[1] = d;
            best[1] = n;
        }
    }

    return new Pair<Neuron, Neuron>(best[0], best[1]);
}
 

import org.apache.commons.math3.ml.distance.DistanceMeasure; //导入方法依赖的package包/类
/**
 * Creates a list of neurons sorted in increased order of the distance
 * to the given {@code features}.
 *
 * @param features Data.
 * @param neurons List of neurons to scan. If it is empty, an empty array
 * will be returned.
 * @param distance Distance function.
 * @return the neurons, sorted in increasing order of distance in data
 * space.
 * @throws org.apache.commons.math3.exception.DimensionMismatchException
 * if the size of the input is not compatible with the neurons features
 * size.
 *
 * @see #findBest(double[],Iterable,DistanceMeasure)
 * @see #findBestAndSecondBest(double[],Iterable,DistanceMeasure)
 *
 * @since 3.6
 */
public static Neuron[] sort(double[] features,
                            Iterable<Neuron> neurons,
                            DistanceMeasure distance) {
    final List<PairNeuronDouble> list = new ArrayList<PairNeuronDouble>();

    for (final Neuron n : neurons) {
        final double d = distance.compute(n.getFeatures(), features);
        list.add(new PairNeuronDouble(n, d));
    }

    Collections.sort(list, PairNeuronDouble.COMPARATOR);

    final int len = list.size();
    final Neuron[] sorted = new Neuron[len];

    for (int i = 0; i < len; i++) {
        sorted[i] = list.get(i).getNeuron();
    }
    return sorted;
}
 

import org.apache.commons.math3.ml.distance.DistanceMeasure; //导入方法依赖的package包/类
/**
 * Computes the quantization error.
 * The quantization error is the average distance between a feature vector
 * and its "best matching unit" (closest neuron).
 *
 * @param data Feature vectors.
 * @param neurons List of neurons to scan.
 * @param distance Distance function.
 * @return the error.
 * @throws NoDataException if {@code data} is empty.
 */
public static double computeQuantizationError(Iterable<double[]> data,
                                              Iterable<Neuron> neurons,
                                              DistanceMeasure distance) {
    double d = 0;
    int count = 0;
    for (double[] f : data) {
        ++count;
        d += distance.compute(f, findBest(f, neurons, distance).getFeatures());
    }

    if (count == 0) {
        throw new NoDataException();
    }

    return d / count;
}
 

import org.apache.commons.math3.ml.distance.DistanceMeasure; //导入方法依赖的package包/类
public DistanceTester withDistanceMeasure(final DistanceMeasure distance) {
    this.distance = new GenericDistanceMeasure<double[]>() {
        private static final long serialVersionUID = -7065467026544814688L;

        @Override
        public double compute(double[] a, double[] b) {
            return distance.compute(a, b);
        }

        @Override
        public double compute(double[] a, double[] b, double cutOffValue) {
            return distance.compute(a, b);
        }
    };
    return this;
}
 

import org.apache.commons.math3.ml.distance.DistanceMeasure; //导入方法依赖的package包/类
/**
 * Computes the <a href="http://en.wikipedia.org/wiki/U-Matrix">
 *  U-matrix</a> of a two-dimensional map.
 *
 * @param map Network.
 * @param distance Function to use for computing the average
 * distance from a neuron to its neighbours.
 * @return the matrix of average distances.
 */
public static double[][] computeU(NeuronSquareMesh2D map,
                                  DistanceMeasure distance) {
    final int numRows = map.getNumberOfRows();
    final int numCols = map.getNumberOfColumns();
    final double[][] uMatrix = new double[numRows][numCols];

    final Network net = map.getNetwork();

    for (int i = 0; i < numRows; i++) {
        for (int j = 0; j < numCols; j++) {
            final Neuron neuron = map.getNeuron(i, j);
            final Collection<Neuron> neighbours = net.getNeighbours(neuron);
            final double[] features = neuron.getFeatures();

            double d = 0;
            int count = 0;
            for (Neuron n : neighbours) {
                ++count;
                d += distance.compute(features, n.getFeatures());
            }

            uMatrix[i][j] = d / count;
        }
    }

    return uMatrix;
}