virtual double operator() (double x)
{
Eigen::Map<Eigen::VectorXd> eigen_f(f->vector, f->vlen);
Eigen::Map<Eigen::VectorXd> eigen_m(m->vector, m->vlen);
*alpha = start_alpha + x*(*dalpha);
(eigen_f) = (*K)*(*alpha)*scale*scale+(eigen_m);
for (index_t i = 0; i < eigen_f.rows(); i++)
(*f)[i] = eigen_f[i];
(*dl1) = lik->get_log_probability_derivative_f(lab, (*f), 1);
(*mW) = lik->get_log_probability_derivative_f(lab, (*f), 2);
float64_t result = ((*alpha).dot(((eigen_f)-(eigen_m))))/2.0;
for (index_t i = 0; i < (*mW).vlen; i++)
(*mW)[i] = -(*mW)[i];
result -= lik->get_log_probability_f(lab, *f);
return result;
}
void CNumericalVGLikelihood::precompute()
{
//samples-by-abscissas
m_log_lam=SGMatrix<float64_t>(m_s2.vlen, m_xgh.vlen);
Map<MatrixXd> eigen_log_lam(m_log_lam.matrix, m_log_lam.num_rows, m_log_lam.num_cols);
Map<VectorXd> eigen_v(m_s2.vector, m_s2.vlen);
Map<VectorXd> eigen_f(m_mu.vector, m_mu.vlen);
Map<VectorXd> eigen_t(m_xgh.vector, m_xgh.vlen);
VectorXd eigen_sv=eigen_v.array().sqrt().matrix();
//varargin{3} = f + sv*t(i); % coordinate transform of the quadrature points
eigen_log_lam = (
(eigen_t.replicate(1, eigen_v.rows()).array().transpose().colwise()
*eigen_sv.array()).colwise()+eigen_f.array()
).matrix();
}
void LevenbergMarquartMinimizer :: minimize(ntk::CostFunction &f,
std::vector<double> &x)
{
m_start_error = f.outputNorm(x);
EigenFunctor eigen_f (f);
NumericalDiff<EigenFunctor> diff_eigen_f(eigen_f, 1e-7);
LevenbergMarquardt< NumericalDiff<EigenFunctor> > eigen_minimizer(diff_eigen_f);
VectorXd eigen_x(f.inputDimension());
std::copy(x.begin(), x.end(), eigen_x.data());
int info = eigen_minimizer.minimize(eigen_x);
m_info = info;
m_num_function_evaluations = eigen_minimizer.nfev;
m_num_iterations = eigen_minimizer.iter;
std::copy(eigen_x.data(), eigen_x.data() + f.inputDimension(), x.begin());
m_end_error = f.outputNorm(x);
}
SGVector<float64_t> CLogitVGPiecewiseBoundLikelihood::get_variational_expection()
{
//This function is based on the Matlab code,
//function [f, gm, gv] = Ellp(m, v, bound, ind), to compute f
//and the formula of the appendix
const Map<VectorXd> eigen_c(m_bound.get_column_vector(0), m_bound.num_rows);
const Map<VectorXd> eigen_b(m_bound.get_column_vector(1), m_bound.num_rows);
const Map<VectorXd> eigen_a(m_bound.get_column_vector(2), m_bound.num_rows);
const Map<VectorXd> eigen_mu(m_mu.vector, m_mu.vlen);
const Map<VectorXd> eigen_s2(m_s2.vector, m_s2.vlen);
Map<VectorXd> eigen_l(m_bound.get_column_vector(3), m_bound.num_rows);
Map<VectorXd> eigen_h(m_bound.get_column_vector(4), m_bound.num_rows);
index_t num_rows = m_bound.num_rows;
index_t num_cols = m_mu.vlen;
const Map<MatrixXd> eigen_cdf_diff(m_cdf_diff.matrix, num_rows, num_cols);
const Map<MatrixXd> eigen_pl(m_pl.matrix, num_rows, num_cols);
const Map<MatrixXd> eigen_ph(m_ph.matrix, num_rows, num_cols);
float64_t l_bak = eigen_l(0);
//l(1) = 0;
eigen_l(0) = 0;
float64_t h_bak = eigen_h(eigen_h.size()-1);
//h(end) = 0;
eigen_h(eigen_h.size()-1) = 0;
//ex0 = ch-cl;
const Map<MatrixXd> & eigen_ex0 = eigen_cdf_diff;
//%ex1= v.*(pl-ph) + m.*(ch-cl);
MatrixXd eigen_ex1 = ((eigen_pl - eigen_ph).array().rowwise()*eigen_s2.array().transpose()
+ eigen_cdf_diff.array().rowwise()*eigen_mu.array().transpose()).matrix();
//ex2 = bsxfun(@times, v, (bsxfun(@plus, l, m)).*pl - (bsxfun(@plus, h, m)).*ph) + bsxfun(@times, (v+m.^2), ex0);
//bsxfun(@plus, l, m)).*pl - (bsxfun(@plus, h, m)).*ph
MatrixXd eigen_ex2 = ((eigen_mu.replicate(1,eigen_l.rows()).array().transpose().colwise() + eigen_l.array())*eigen_pl.array()
- (eigen_mu.replicate(1,eigen_h.rows()).array().transpose().colwise() + eigen_h.array())*eigen_ph.array()).matrix();
//bsxfun(@times, v, (bsxfun(@plus, l, m).*pl - bsxfun(@plus, h, m).*ph
eigen_ex2 = (eigen_ex2.array().rowwise()*eigen_s2.array().transpose()).matrix();
//ex2 = bsxfun(@times, v, (bsxfun(@plus, l, m)).*pl - (bsxfun(@plus, h, m)).*ph) + bsxfun(@times, (v+m.^2), ex0);
eigen_ex2 += (eigen_cdf_diff.array().rowwise()*(eigen_mu.array().pow(2)
+ eigen_s2.array()).transpose()).matrix();
SGVector<float64_t> f(m_mu.vlen);
Map<VectorXd> eigen_f(f.vector, f.vlen);
//%f = sum((a.*ex2 + b.*ex1 + c.*ex0),1);
eigen_f = (eigen_ex2.array().colwise()*eigen_a.array()
+ eigen_ex1.array().colwise()*eigen_b.array()
+ eigen_ex0.array().colwise()*eigen_c.array()).colwise().sum().matrix();
eigen_l(0) = l_bak;
eigen_h(eigen_h.size()-1) = h_bak;
Map<VectorXd>eigen_lab(m_lab.vector, m_lab.vlen);
eigen_f = eigen_lab.cwiseProduct(eigen_mu) - eigen_f;
return f;
}
