Eigen::VectorXi LDA<Scalar>::predict(const MatrixX &scores) {
Eigen::VectorXi predictions(scores.cols());
for (int d=0; d<scores.cols(); d++) {
scores.col(d).maxCoeff( &predictions[d] );
}
return predictions;
}
GMMExpectationMaximization::uint GMMExpectationMaximization::execute(const MatrixX & dataset)
{
const uint data_count = dataset.rows();
const uint num_gaussians = m_means.size();
const uint dim = dataset.cols();
MatrixX pxi(data_count,num_gaussians);
MatrixX pix(data_count,num_gaussians);
VectorX pxidatatot(data_count);
VectorX weights(num_gaussians);
VectorX ex(data_count);
MatrixX ts(dim,dim);
VectorX dif(dim);
Real prev_log_likelyhood = 1.0;
uint it_num;
for (it_num = 0; it_num < m_max_iterations; it_num++)
{
for (uint g = 0; g < num_gaussians; g++)
weights[g] = m_weights[g];
for (uint d = 0; d < data_count; d++)
for (uint g = 0; g < num_gaussians; g++)
pxi(d,g) = gauss(m_means[g],m_covs[g],dataset.row(d).transpose());
pxidatatot = pxi * weights;
Real log_likelyhood = pxidatatot.array().log().sum() / Real(data_count);
if (it_num != 0 && (std::abs(log_likelyhood / prev_log_likelyhood - 1.0) < m_termination_threshold))
break;
prev_log_likelyhood = log_likelyhood;
for (uint d = 0; d < data_count; d++)
pix.row(d) = (pxi.row(d).transpose().array() * weights.array()).transpose() / pxidatatot[d];
ex = pix.colwise().sum();
for(uint g = 0; g < num_gaussians; g++)
{
m_weights[g] = ex[g] / Real(data_count);
m_means[g] = (dataset.transpose() * pix.col(g)) / ex[g];
ts = MatrixX::Zero(dim,dim);
for (uint d = 0; d < data_count; d++)
{
dif = dataset.row(d).transpose() - m_means[g];
ts.noalias() += (dif * dif.transpose()) * pix(d,g);
}
m_covs[g] = (ts / ex[g]) + MatrixX::Identity(dim,dim) * m_epsilon;
}
// interruption point here
if (m_termination_handler && m_termination_handler->isTerminated())
return it_num;
}
return it_num;
}
/**
* In this test we check if the gradient is correct by appling
* a finite difference method.
*/
TYPED_TEST(TestSecondOrderMultinomialLogisticRegression, Gradient) {
// Gradient checking should only be made with a double type
if (is_float<TypeParam>::value) {
return;
}
// eta is typically of size KxC, where K is the number of topics and C the
// number of different classes.
// Here we choose randomly for conviency K=10 and C=5
MatrixX<TypeParam> eta = MatrixX<TypeParam>::Random(10, 5);
// X is of size KxD, where D is the total number of documents.
// In our case we have chosen D=15
MatrixX<TypeParam> X = MatrixX<TypeParam>::Random(10, 1);
// y is vector of size Dx1
VectorXi y(1);
for (int i=0; i<1; i++) {
y(i) = rand() % (int)5;
}
std::vector<MatrixX<TypeParam> > X_var = {MatrixX<TypeParam>::Random(10, 10).array().abs()};
TypeParam L = 1;
SecondOrderLogisticRegressionApproximation<TypeParam> mlr(X, X_var, y, L);
// grad is the gradient according to the equation
// implemented in MultinomialLogisticRegression.cpp
// gradient function
// grad is of same size as eta, which is KxC
MatrixX<TypeParam> grad(10, 5);
// Calculate the gradients
mlr.gradient(eta, grad);
// Grad's approximation
TypeParam grad_hat;
TypeParam t = 1e-6;
for (int i=0; i < eta.rows(); i++) {
for (int j=0; j < eta.cols(); j++) {
eta(i, j) += t;
TypeParam ll1 = mlr.value(eta);
eta(i, j) -= 2*t;
TypeParam ll2 = mlr.value(eta);
// Compute gradients approximation
grad_hat = (ll1 - ll2) / (2 * t);
auto absolute_error = std::abs(grad(i, j) - grad_hat);
if (grad_hat != 0) {
auto relative_error = absolute_error / std::abs(grad_hat);
EXPECT_TRUE(
relative_error < 1e-4 ||
absolute_error < 1e-5
) << relative_error << " " << absolute_error;
}
else {
EXPECT_LT(absolute_error, 1e-5);
}
}
}
}
GMMExpectationMaximization::Real GMMExpectationMaximization::getBIC(const MatrixX & dataset) const
{
const uint dim = dataset.cols();
const uint num_gaussians = m_means.size();
Real number_of_parameters = (num_gaussians * dim * (dim + 1) / 2) + num_gaussians * dim + num_gaussians - 1;
uint data_count = dataset.rows();
Real sum = 0.0;
for(uint i = 0; i < data_count; i++)
sum += log(expectation(dataset.row(i).transpose()));
return -sum + (number_of_parameters / 2.0) * log(Real(data_count));
}
const MatrixX& Jacobian::GetNullspace()
{
if(computeNullSpace_)
{
computeNullSpace_ = false;
/*jacobianInverseNoDls_ = jacobian_;
PseudoInverse(jacobianInverseNoDls_); // tmp while figuring out how to chose lambda*/
//ComputeSVD();
MatrixX id = MatrixX::Identity(jacobian_.cols(), jacobian_.cols());
ComputeSVD();
//Eigen::JacobiSVD<MatrixX> svd(jacobian_, Eigen::ComputeThinU | Eigen::ComputeThinV);
MatrixX res = MatrixX::Zero(id.rows(), id.cols());
for(int i =0; i < svd_.matrixV().cols(); ++ i)
{
VectorX v = svd_.matrixV().col(i);
res += v * v.transpose();
}
Identitymin_ = id - res;
//Identitymin_ = id - (jacobianInverseNoDls_* jacobian_);
}
return Identitymin_;
}
bool GaussianSet::setSpinDensityMatrix(const MatrixX &m)
{
m_spinDensity.resize(m.rows(), m.cols());
m_spinDensity = m;
return true;
}
void GMMExpectationMaximization::autoInitializeByEqualIntervals(uint num_gaussians,uint col,const MatrixX & dataset)
{
uint data_count = dataset.rows();
uint dim = dataset.cols();
std::vector<std::vector<uint> > index(num_gaussians);
for(uint g = 0; g < num_gaussians; g++)
index[g].reserve(data_count / num_gaussians);
m_weights.clear();
m_weights.resize(num_gaussians);
m_means.clear();
m_means.resize(num_gaussians,VectorX::Zero(dim));
m_covs.clear();
m_covs.resize(num_gaussians,MatrixX::Zero(dim,dim));
// find max and min value for column col
Real cmax = dataset(0,col);
Real cmin = dataset(0,col);
for(uint n = 1; n < data_count; n++)
{
if (dataset(n,col) > cmax) cmax = dataset(n,col);
if (dataset(n,col) < cmin) cmin = dataset(n,col);
}
Real cspan = cmax - cmin;
for(uint n = 0; n < data_count; n++)
{
// compute gaussian index to which this point belongs
uint gi = uint((dataset(n,col) - cmin) / (cspan + 1.0) * Real(num_gaussians));
// sum the points to obtain means
m_means[gi] += dataset.row(n);
index[gi].push_back(n);
}
for (uint g = 0; g < num_gaussians; g++)
{
uint popsize = index[g].size();
// avoid division by zero: if no samples are available, initialize to something from somewhere
if (popsize == 0)
{
m_means[g] = dataset.row(g % data_count);
m_covs[g] = MatrixX::Identity(dim,dim);
m_weights[g] = 1.0f / Real(num_gaussians);
continue;
}
// average by popsize
m_means[g] /= Real(popsize);
// same weight for all gaussians
m_weights[g] = 1.0f / Real(num_gaussians);
// compute covariance matrix
for (uint p = 0; p < popsize; p++)
{
const Eigen::VectorXf & r = dataset.row(index[g][p]);
const Eigen::VectorXf & m = m_means[g];
m_covs[g] += (r - m) * (r - m).transpose();
}
m_covs[g] /= Real(popsize);
m_covs[g] += MatrixX::Identity(dim,dim) * m_epsilon;
}
}
