#include <gmm.hpp>

Collaboration diagram for jubatus::core::clustering::gmm:

Public Member Functions
void	batch (const eigen_wsvec_list_t &data, int d, int k)

eigen_svec_list_t	get_centers ()

eigen_smat_list_t	get_covs ()

eigen_svec_t	get_nearest_center (const eigen_svec_t &p) const

int64_t	get_nearest_center_index (const eigen_svec_t &p) const

Private Member Functions
eigen_svec_t	cluster_probs (const eigen_svec_t &x, const eigen_svec_list_t &mean, const eigen_smat_list_t &cov, const eigen_solver_list_t &solvers) const

void	initialize (const eigen_wsvec_list_t &data, int d, int k)

bool	is_converged (int64_t niter, const eigen_svec_list_t &means, const eigen_svec_list_t &old_means, double obj, double old_obj)

Private Attributes
eigen_solver_list_t	cov_solvers_

eigen_smat_list_t	covs_

int	d_

eigen_smat_t	eye_

int	k_

eigen_svec_list_t	means_

Detailed Description

Definition at line 26 of file gmm.hpp.

Member Function Documentation

void jubatus::core::clustering::gmm::batch	(	const eigen_wsvec_list_t &	data,
		int	d,
		int	k
	)

Definition at line 40 of file gmm.cpp.

References cluster_probs(), cov_solvers_, covs_, eye_, initialize(), is_converged(), and means_.

Referenced by jubatus::core::clustering::gmm_clustering_method::batch_update().

                                                             {
   if (data.empty()) {
     *this = gmm();
     return;
   }
 
   typedef eigen_wsvec_list_t::const_iterator data_iter;
   initialize(data, d, k);
 
   eigen_svec_list_t old_means;
   eigen_smat_list_t old_covs;
   eigen_solver_list_t old_solvers;
   double old_obj = 0, obj = 0;
   vector<double> weights(k);
 
   bool converged = false;
   int64_t niter = 1;
   while (!converged) {
     old_covs = covs_;
     old_means = means_;
     old_solvers = cov_solvers_;
     old_obj = obj;
     obj = 0;
     fill(weights.begin(), weights.end(), 0);
     fill(means_.begin(), means_.end(), eigen_svec_t(d));
     fill(covs_.begin(), covs_.end(), eigen_smat_t(d, d));
 
     for (data_iter i = data.begin(); i != data.end(); ++i) {
       eigen_svec_t cps =
           cluster_probs(i->data, old_means, old_covs, old_solvers);
       for (int c = 0; c < k; ++c) {
         double cp = i->weight * cps.coeff(c);
         means_[c] += cp * i->data;
         covs_[c] += i->data * (i->data.transpose()) * cp;
         weights[c] += cp;
         obj -= std::log(std::max(cp, std::numeric_limits<double>::min()));
       }
     }
     for (int c = 0; c < k; ++c) {
       means_[c] /= weights[c];
       covs_[c] /= weights[c];
       double eps = 0.1;
       covs_[c] -= means_[c] * means_[c].transpose();
       covs_[c] += eps * eye_;
       cov_solvers_[c] =
           shared_ptr<eigen_solver_t>(new eigen_solver_t(covs_[c]));
     }
     converged = is_converged(niter++, means_, old_means, obj, old_obj);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

eigen_svec_t jubatus::core::clustering::gmm::cluster_probs	(	const eigen_svec_t &	x,
		const eigen_svec_list_t &	mean,
		const eigen_smat_list_t &	cov,
		const eigen_solver_list_t &	solvers
	)		const

private

Definition at line 149 of file gmm.cpp.

References k_, and jubatus::core::clustering::sum().

Referenced by batch(), and get_nearest_center_index().

                                                   {
   double den = DBL_MIN;
   eigen_svec_t ret(k_);
   for (int i = 0; i < k_; ++i) {
     eigen_svec_t dif = x - means[i];
     double det = std::abs(cov_solvers[i]->determinant());
     double quad = (dif.transpose() * cov_solvers[i]->solve(dif)).sum();
     double lp = -1 / 2. * (std::log(det) + quad);
     ret.coeffRef(i) = lp;
     den = (den == DBL_MIN) ?
         lp : std::max(den, lp) +
             std::log(1 + std::exp(min(den, lp) - std::max(den, lp)));
   }
   for (int i = 0; i < k_; ++i) {
     ret.coeffRef(i) = std::exp(ret.coeff(i) - den);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

eigen_svec_list_t jubatus::core::clustering::gmm::get_centers ( )

inline

Definition at line 29 of file gmm.hpp.

References means_.

Referenced by jubatus::core::clustering::gmm_clustering_method::batch_update().

                                   {
     return means_;
   }

Here is the caller graph for this function:

eigen_smat_list_t jubatus::core::clustering::gmm::get_covs ( )

inline

Definition at line 32 of file gmm.hpp.

References covs_.

                                {
     return covs_;
   }

eigen_svec_t jubatus::core::clustering::gmm::get_nearest_center ( const eigen_svec_t & p ) const

Definition at line 91 of file gmm.cpp.

References get_nearest_center_index(), and means_.

Referenced by jubatus::core::clustering::gmm_clustering_method::get_nearest_center().

                                                                 {
   return means_[get_nearest_center_index(p)];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t jubatus::core::clustering::gmm::get_nearest_center_index ( const eigen_svec_t & p ) const

Definition at line 95 of file gmm.cpp.

References cluster_probs(), cov_solvers_, covs_, JUBATUS_EXCEPTION, k_, and means_.

Referenced by get_nearest_center(), and jubatus::core::clustering::gmm_clustering_method::get_nearest_center_index().

                                                                  {
   if (means_.empty()) {
     throw JUBATUS_EXCEPTION(common::exception::runtime_error(
         "clustering is not performed yet"));
   }
 
   double max_prob = 0;
   int64_t max_idx = 0;
   eigen_svec_t cps = cluster_probs(p, means_, covs_, cov_solvers_);
   for (int c = 0; c < k_; ++c) {
     double cp = cps.coeff(c);
     if (cp > max_prob) {
       max_prob = cp;
       max_idx = c;
     }
   }
   return max_idx;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void jubatus::core::clustering::gmm::initialize	(	const eigen_wsvec_list_t &	data,
		int	d,
		int	k
	)

private

Definition at line 114 of file gmm.cpp.

References cov_solvers_, covs_, d_, eye_, k_, and means_.

Referenced by batch().

                                                                  {
   d_ = d;
   k_ = k;
   means_ = eigen_svec_list_t(k);
   covs_ = eigen_smat_list_t(k, eigen_smat_t(d, d));
   cov_solvers_ = eigen_solver_list_t(k);
   eye_ = eigen_smat_t(d, d);
 
   for (int i = 0; i < d; ++i) {
     eye_.insert(i, i) = 1;
   }
 
   jubatus::util::math::random::mtrand r(time(NULL));
   for (int c = 0; c < k; ++c) {
     means_[c] = data[r.next_int(0, data.size()-1)].data;
     for (int i = 0; i < d; ++i) {
       covs_[c].insert(i, i) = 1;
     }
     cov_solvers_[c] = shared_ptr<eigen_solver_t>(new eigen_solver_t(covs_[c]));
   }
 }

Here is the caller graph for this function:

bool jubatus::core::clustering::gmm::is_converged	(	int64_t	niter,
		const eigen_svec_list_t &	means,
		const eigen_svec_list_t &	old_means,
		double	obj,
		double	old_obj
	)

private

Definition at line 136 of file gmm.cpp.

References k_.

Referenced by batch().

                     {
   double max_dist = 0;
   for (int c = 0; c < k_; ++c) {
     max_dist = max(max_dist, (means[c] - old_means[c]).norm());
   }
   return (max_dist < 1e-09 || niter > 1e05);
 }