drwnGaussianMixture.h

/******************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnGaussianMixture.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <vector>
#include <limits>

#include "Eigen/Core"
#include "Eigen/Cholesky"
#include "Eigen/LU"

#include "drwnBase.h"
#include "drwnSuffStats.h"

using namespace std;
using namespace Eigen;

// drwnGaussianMixture ------------------------------------------------------

class drwnGaussianMixture : public drwnStdObjIface {
public:
    static int MAX_ITERATIONS;

protected:
    unsigned _n;               
    vector<drwnGaussian> _g;   
    VectorXd _logLambda;       

public:
    drwnGaussianMixture(unsigned n = 1, unsigned k = 1);
    virtual ~drwnGaussianMixture();

    // initialization
    void initialize(unsigned n, unsigned k);

    // i/o
    const char *type() const { return "drwnGaussianMixture"; }
    drwnGaussianMixture *clone() const { return new drwnGaussianMixture(*this); }
    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);

    // evaluate (log-likelihood)
    void evaluate(const MatrixXd& x, VectorXd& p) const;
    void evaluate(const vector<vector<double> >& x, vector<double>& p) const;
    double evaluateSingle(const VectorXd& x) const;
    double evaluateSingle(const vector<double>& x) const;

    // sampling
    void sample(VectorXd& x) const;
    void sample(vector<double>& x) const;

    // learn parameters
    void train(const MatrixXd& x, double lambda = 1.0e-3);
    void train(const vector<vector<double> >& x, double lambda = 1.0e-3);

    // access
    unsigned mixtures() const { return _g.size(); }
    unsigned dimension() const { return _n; }
    double weight(int k) const { return exp(_logLambda[k]); }
    const VectorXd& mean(int k) const { return _g[k].mean(); }
    const MatrixXd& covariance(int k) const { return _g[k].covariance(); }
    const drwnGaussian& component(int k) const { return _g[k]; }

    // standard operators
    drwnGaussianMixture& operator=(const drwnGaussianMixture& model);
};