Example usage for org.apache.commons.math3.distribution MultivariateNormalDistribution MultivariateNormalDistribution

List of usage examples for org.apache.commons.math3.distribution MultivariateNormalDistribution MultivariateNormalDistribution

Introduction

In this page you can find the example usage for org.apache.commons.math3.distribution MultivariateNormalDistribution MultivariateNormalDistribution.

Prototype

public MultivariateNormalDistribution(RandomGenerator rng, final double[] means, final double[][] covariances)
        throws SingularMatrixException, DimensionMismatchException, NonPositiveDefiniteMatrixException 

Source Link

Document

Creates a multivariate normal distribution with the given mean vector and covariance matrix.

Usage

From source file:edu.oregonstate.eecs.mcplan.ml.KernelPrincipalComponentsAnalysis.java

public static void main(final String[] args) throws FileNotFoundException {
    final File root = new File("test/KernelPrincipalComponentsAnalysis");
    root.mkdirs();/*  ww w.  j a v  a  2s.  c o  m*/
    final int seed = 42;
    final int N = 30;
    final RandomGenerator rng = new MersenneTwister(seed);
    final ArrayList<RealVector> data = new ArrayList<RealVector>();
    final ArrayList<RealVector> shuffled = new ArrayList<RealVector>();

    //      final double[][] covariance = new double[][] { {1.0, 0.0},
    //                                          {0.0, 1.0} };
    //      final MultivariateNormalDistribution p = new MultivariateNormalDistribution(
    //         rng, new double[] { 0.0, 0.0 }, covariance );
    //      final MultivariateNormalDistribution q = new MultivariateNormalDistribution(
    //         rng, new double[] { 10.0, 0.0 }, covariance );
    //
    //      for( int i = 0; i < N; ++i ) {
    //         data.add( new ArrayRealVector( p.sample() ) );
    //         data.add( new ArrayRealVector( q.sample() ) );
    //      }
    //      Fn.shuffle( rng, data );

    final double sigma = 0.01;
    final double[][] covariance = new double[][] { { sigma, 0.0 }, { 0.0, sigma } };
    final MultivariateNormalDistribution p = new MultivariateNormalDistribution(rng, new double[] { 0.0, 0.0 },
            covariance);

    for (final double r : new double[] { 1.0, 3.0, 5.0 }) {
        for (int i = 0; i < N; ++i) {
            final double theta = i * 2 * Math.PI / N;
            final double[] noise = p.sample();
            final RealVector v = new ArrayRealVector(
                    new double[] { r * Math.cos(theta) + noise[0], r * Math.sin(theta) + noise[1] });
            data.add(v);
            shuffled.add(v);
        }
    }
    Fn.shuffle(rng, shuffled);

    final Csv.Writer data_writer = new Csv.Writer(new PrintStream(new File(root, "data.csv")));
    for (final RealVector v : data) {
        for (int i = 0; i < v.getDimension(); ++i) {
            data_writer.cell(v.getEntry(i));
        }
        data_writer.newline();
    }
    data_writer.close();

    System.out.println("[Training]");
    final int Ncomponents = 2;
    final KernelPrincipalComponentsAnalysis<RealVector> kpca = new KernelPrincipalComponentsAnalysis<RealVector>(
            shuffled, new RadialBasisFunctionKernel(0.5), 1e-6);
    System.out.println("[Finished]");
    for (int i = 0; i < Ncomponents; ++i) {
        System.out.println(kpca.eigenvectors.get(i));
    }

    System.out.println("Transformed data:");
    final KernelPrincipalComponentsAnalysis.Transformer<RealVector> transformer = kpca
            .makeTransformer(Ncomponents);
    final Csv.Writer transformed_writer = new Csv.Writer(new PrintStream(new File(root, "transformed.csv")));
    for (final RealVector u : data) {
        final RealVector v = transformer.transform(u);
        System.out.println(v);
        for (int i = 0; i < v.getDimension(); ++i) {
            transformed_writer.cell(v.getEntry(i));
        }
        transformed_writer.newline();
    }
    transformed_writer.close();
}

From source file:edu.oregonstate.eecs.mcplan.ml.Datasets.java

public static Pair<ArrayList<double[]>, int[]> twoVerticalGaussian2D(final RandomGenerator rng,
        final int Nper_class) {
    final int Nclasses = 2;
    final ArrayList<double[]> X = new ArrayList<double[]>();
    final int[] Y = new int[Nclasses * Nper_class];

    final double[][] covariance = new double[][] { { 0.1 * 0.1, 0.0 }, { 0.0, 1 } };
    final MultivariateNormalDistribution p = new MultivariateNormalDistribution(rng, new double[] { 0.0, 0.0 },
            covariance);/*from  w w  w.  j av a2s. c o  m*/

    for (int c = 0; c < Nclasses; ++c) {
        for (int i = 0; i < Nper_class; ++i) {
            final double[] x = p.sample();
            x[0] += c;
            X.add(x);
            Y[c * Nper_class + i] = c;
        }
    }

    return Pair.makePair(X, Y);
}

From source file:edu.oregonstate.eecs.mcplan.ml.GaussianMixtureModel.java

/**
 * @param args/*from   w  w  w .  ja  va  2s  . c o m*/
 */
public static void main(final String[] args) {
    final RandomGenerator rng = new MersenneTwister(42);
    final ArrayList<double[]> data = new ArrayList<double[]>();

    // This data displays some problems with singular covariance estimates,
    // perhaps due to "multicollinearity" in the data.
    //      for( int x = -1; x <= 1; ++x ) {
    //         for( int y = -1; y <= 1; ++y ) {
    //            data.add( new double[] { x, y } );
    //            data.add( new double[] { x + 10, y + 10} );
    //            data.add( new double[] { x + 20, y + 20} );
    //            data.add( new double[] { x + 30, y + 30} );
    //         }
    //      }

    final int nsamples = 1000;
    final double[][] mu = new double[][] { new double[] { 0, 0 }, new double[] { 5, 0 }, new double[] { 0, 5 },
            new double[] { 5, 5 } };
    final double[][] Sigma = new double[][] { new double[] { 1, 0 }, new double[] { 0, 1 } };
    final MultivariateNormalDistribution[] p = new MultivariateNormalDistribution[4];
    for (int i = 0; i < 4; ++i) {
        p[i] = new MultivariateNormalDistribution(rng, mu[i], Sigma);
    }
    for (int i = 0; i < nsamples; ++i) {
        final int c = rng.nextInt(4);
        final double[] x = p[c].sample();
        data.add(x);
    }

    // Perturb data
    //      for( final double[] x : data ) {
    //         for( int i = 0; i < x.length; ++i ) {
    //            final double r = rng.nextGaussian() / 1.0;
    //            x[i] += r;
    //         }
    //      }

    double best_bic = Double.MAX_VALUE;
    int best_k = 0;
    for (int k = 1; k <= 6; ++k) {
        System.out.println("*** k = " + k);
        final GaussianMixtureModel gmm = new GaussianMixtureModel(k, data.toArray(new double[data.size()][]),
                10e-5, rng);

        gmm.run();
        for (int i = 0; i < gmm.mu().length; ++i) {
            System.out.println("Center " + i + ": " + gmm.mu()[i]);
        }

        final double bic = ScoreFunctions.bic(data.size(), gmm.nparameters(), gmm.logLikelihood());
        System.out.println("BIC = " + bic);
        System.out.println("ll = " + gmm.logLikelihood());
        gmm.debug();
        if (bic < best_bic) {
            best_bic = bic;
            best_k = k;
        }
    }
    System.out.println("Best model: k = " + best_k);
}

From source file:io.coala.random.impl.RandomDistributionFactoryImpl.java

@Override
public RandomDistribution<double[]> getMultivariateNormal(final RandomNumberStream rng, final double[] means,
        final double[][] covariances) {
    final MultivariateRealDistribution dist = new MultivariateNormalDistribution(
            RandomNumberStream.Util.asCommonsRandomGenerator(rng), means, covariances);
    return new RandomDistribution<double[]>() {
        @Override/* www. j av  a 2  s  . co m*/
        public double[] draw() {
            return dist.sample();
        }
    };
}