de.lmu.ifi.dbs.elki.math.statistics.dependence

Class MCEDependenceMeasure

java.lang.Object

de.lmu.ifi.dbs.elki.math.statistics.dependence.AbstractDependenceMeasure

de.lmu.ifi.dbs.elki.math.statistics.dependence.MCEDependenceMeasure

All Implemented Interfaces:

DependenceMeasure

@Reference(authors="D. Guo",
           title="Coordinating computational and visual approaches for interactive feature selection and multivariate clustering",
           booktitle="Information Visualization, 2(4)",
           url="http://dx.doi.org/10.1057/palgrave.ivs.9500053")
public class MCEDependenceMeasure
extends AbstractDependenceMeasure

Compute a mutual information based dependence measure using a nested means discretization, originally proposed for ordering axes in parallel coordinate plots. Reference:

D. Guo
Coordinating computational and visual approaches for interactive feature selection and multivariate clustering
Information Visualization, 2(4), 2003.

Author:

Erich Schubert

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	MCEDependenceMeasure.Parameterizer Parameterization class.

Field Summary

Fields

Modifier and Type	Field and Description
static MCEDependenceMeasure	STATIC Static instance.
static int	TARGET Desired size: 35 observations.

Constructor Summary

Constructors

Constructor and Description
MCEDependenceMeasure()

Method Summary

Modifier and Type	Method and Description
private <A> ArrayList<int[]>	buildPartitions(NumberArrayAdapter<?,A> adapter1, A data1, int len, int depth) Partitions an attribute.
<A,B> double	dependence(NumberArrayAdapter<?,A> adapter1, A data1, NumberArrayAdapter<?,B> adapter2, B data2) Measure the dependence of two variables.
private void	divide(int[] idx, double[] data, ArrayList<int[]> ret, int start, int end, int depth) Recursive call to further subdivide the array.
private double	getMCEntropy(int[][] mat, ArrayList<int[]> partsx, ArrayList<int[]> partsy, int size, int gridsize, double loggrid) Compute the MCE entropy value.
private void	intersectionMatrix(int[][] res, ArrayList<int[]> partsx, ArrayList<int[]> partsy, int gridsize) Intersect the two 1d grid decompositions, to obtain a 2d matrix.
private int	intersectionSize(int[] px, int[] py) Compute the intersection of two sorted integer lists.

Methods inherited from class de.lmu.ifi.dbs.elki.math.statistics.dependence.AbstractDependenceMeasure

clamp, computeNormalizedRanks, dependence, dependence, dependence, discretize, index, ranks, ranks, size, size, sortedIndex

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

STATIC

public static final MCEDependenceMeasure STATIC

Static instance.

TARGET

public static final int TARGET

Desired size: 35 observations. While this could trivially be made parameterizable, it is a reasonable rule of thumb and not expected to have a major effect.

See Also:

Constant Field Values

Constructor Detail

MCEDependenceMeasure

public MCEDependenceMeasure()

Method Detail

dependence

public <A,B> double dependence(NumberArrayAdapter<?,A> adapter1,
                               A data1,
                               NumberArrayAdapter<?,B> adapter2,
                               B data2)

Description copied from interface: DependenceMeasure

Measure the dependence of two variables. This is the more flexible API, which allows using different internal data representations.

Specified by:

dependence in interface DependenceMeasure

Specified by:

dependence in class AbstractDependenceMeasure

Type Parameters:

A - First array type

B - Second array type

Parameters:

adapter1 - First data adapter

data1 - First data set

adapter2 - Second data adapter

data2 - Second data set

Returns:

Dependence measure

buildPartitions

private <A> ArrayList<int[]> buildPartitions(NumberArrayAdapter<?,A> adapter1,
                                             A data1,
                                             int len,
                                             int depth)

Partitions an attribute.

Parameters:

adapter1 - Data adapter

data1 - Data set

len - Length of data

depth - Splitting depth

Returns:

List of sorted objects

divide

private void divide(int[] idx,
                    double[] data,
                    ArrayList<int[]> ret,
                    int start,
                    int end,
                    int depth)

Recursive call to further subdivide the array.

Parameters:

idx - Object indexes.

data - 1D data, sorted

ret - Output index

start - Interval start

end - Interval end

depth - Depth

intersectionMatrix

private void intersectionMatrix(int[][] res,
                                ArrayList<int[]> partsx,
                                ArrayList<int[]> partsy,
                                int gridsize)

Intersect the two 1d grid decompositions, to obtain a 2d matrix.

Parameters:

res - Output matrix to fill

partsx - Partitions in first component

partsy - Partitions in second component.

gridsize - Size of partition decomposition

intersectionSize

private int intersectionSize(int[] px,
                             int[] py)

Compute the intersection of two sorted integer lists.

Parameters:

px - First list

py - Second list

Returns:

Intersection size.

getMCEntropy

private double getMCEntropy(int[][] mat,
                            ArrayList<int[]> partsx,
                            ArrayList<int[]> partsy,
                            int size,
                            int gridsize,
                            double loggrid)

Compute the MCE entropy value.

Parameters:

mat - Partition size matrix

partsx - Partitions on X

partsy - Partitions on Y

size - Data set size

gridsize - Size of grids

loggrid - Logarithm of grid sizes, for normalization

Returns:

MCE score.