double HierarchicalGaussianProcess::negativeTotalLogLikelihood()
{
/*This is the restricted version. For the unrestricted, make p=0
and remove the last term of loglik*/
const matrixd K = computeCorrMatrix();
const size_t n = K.size1();
const size_t p = mFeatM.size1();
matrixd L(n,n);
utils::cholesky_decompose(K,L);
matrixd KF(ublas::trans(mFeatM));
inplace_solve(L,KF,ublas::lower_tag());
matrixd FKF = prod(ublas::trans(KF),KF);
matrixd L2(p,p);
utils::cholesky_decompose(FKF,L2);
vectord Ky(mGPY);
inplace_solve(L,Ky,ublas::lower_tag());
vectord wML = prod(Ky,KF);
utils::cholesky_solve(L2,wML,ublas::lower());
vectord alpha = mGPY - prod(wML,mFeatM);
inplace_solve(L,alpha,ublas::lower_tag());
double sigma = ublas::inner_prod(alpha,alpha)/(n-p);
double loglik = .5*(n-p)*log(ublas::inner_prod(alpha,alpha))
+ utils::log_trace(L) + utils::log_trace(L2);
return loglik;
}
void StudentTProcessJeffreys::precomputePrediction()
{
size_t n = mData.getNSamples();
size_t p = mMean.nFeatures();
mKn.resize(n);
mKF = trans(mMean.mFeatM);
inplace_solve(mL,mKF,ublas::lower_tag());
matrixd FKF = prod(trans(mKF),mKF);
mL2 = FKF;
utils::cholesky_decompose(FKF,mL2);
vectord Ky(mData.mY);
inplace_solve(mL,Ky,ublas::lower_tag());
mWML = prod(Ky,mKF);
utils::cholesky_solve(mL2,mWML,ublas::lower());
mAlphaF = mData.mY - prod(mWML,mMean.mFeatM);
inplace_solve(mL,mAlphaF,ublas::lower_tag());
mSigma = inner_prod(mAlphaF,mAlphaF)/(n-p);
d_->setDof(n-p);
}
void lu_substitute(matrix<SCALARTYPE, F, ALIGNMENT> const & A,
vector<SCALARTYPE, VEC_ALIGNMENT> & vec)
{
assert(A.size1() == A.size2() && bool("Matrix must be square"));
inplace_solve(A, vec, unit_lower_tag());
inplace_solve(A, vec, upper_tag());
}
ProbabilityDistribution*
GaussianProcessNormal::prediction(const vectord &query)
{
double kq = (*mKernel)(query, query);;
vectord kn = computeCrossCorrelation(query);
vectord phi = mMean->getFeatures(query);
vectord v(kn);
inplace_solve(mL,v,ublas::lower_tag());
vectord rq = phi - prod(v,mKF);
vectord rho(rq);
inplace_solve(mD,rho,ublas::lower_tag());
double yPred = inner_prod(phi,mWMap) + inner_prod(v,mVf);
double sPred = sqrt( mSigma * (kq - inner_prod(v,v)
+ inner_prod(rho,rho)));
if ((boost::math::isnan(yPred)) || (boost::math::isnan(sPred)))
{
FILE_LOG(logERROR) << "Error in prediction. NaN found.";
exit(EXIT_FAILURE);
}
d_->setMeanAndStd(yPred,sPred);
return d_;
}
ProbabilityDistribution* StudentTProcessNIG::prediction(const vectord &query)
{
double kq = computeSelfCorrelation(query);
vectord kn = computeCrossCorrelation(query);
vectord phi = mMean.getFeatures(query);
vectord v(kn);
inplace_solve(mL,v,ublas::lower_tag());
vectord rq = phi - prod(v,mKF);
vectord rho(rq);
inplace_solve(mD,rho,ublas::lower_tag());
double yPred = inner_prod(phi,mWMap) + inner_prod(v,mVf);
double sPred = sqrt( mSigma * (kq - inner_prod(v,v)
+ inner_prod(rho,rho)));
if ((boost::math::isnan(yPred)) || (boost::math::isnan(sPred)))
{
throw std::runtime_error("Error in prediction. NaN found.");
}
d_->setMeanAndStd(yPred,sPred);
return d_;
}
void lu_substitute(matrix<SCALARTYPE, F, ALIGNMENT> const & mat,
vector<SCALARTYPE, VEC_ALIGNMENT> & vec)
{
assert(mat.size1() == mat.size2());
inplace_solve(mat, vec, unit_lower_tag());
inplace_solve(mat, vec, upper_tag());
}
int GaussianProcessNormal::precomputePrediction()
{
size_t n = mGPXX.size();
size_t p = mMean->nFeatures();
mKF = trans(mFeatM);
inplace_solve(mL,mKF,ublas::lower_tag());
//TODO: make one line
matrixd DD(p,p);
DD = prod(trans(mKF),mKF);
utils::addToDiagonal(DD,mInvVarW);
utils::cholesky_decompose(DD,mD);
vectord vn = mGPY;
inplace_solve(mL,vn,ublas::lower_tag());
mWMap = prod(mFeatM,vn) + utils::ublas_elementwise_prod(mInvVarW,mW0);
utils::cholesky_solve(mD,mWMap,ublas::lower());
mVf = mGPY - prod(trans(mFeatM),mWMap);
inplace_solve(mL,mVf,ublas::lower_tag());
if (boost::math::isnan(mWMap(0)))
{
FILE_LOG(logERROR) << "Error in precomputed prediction. NaN found.";
return -1;
}
return 0;
}
void lu_substitute(matrix<SCALARTYPE, F1, ALIGNMENT_A> const & A,
matrix<SCALARTYPE, F2, ALIGNMENT_B> & B)
{
assert(A.size1() == A.size2());
assert(A.size1() == A.size2());
inplace_solve(A, B, unit_lower_tag());
inplace_solve(A, B, upper_tag());
}
void StudentTProcessNIG::precomputePrediction()
{
size_t n = mData.getNSamples();
size_t p = mMean.nFeatures();
mKF = trans(mMean.mFeatM);
inplace_solve(mL,mKF,ublas::lower_tag());
//TODO: make one line
matrixd DD(p,p);
DD = prod(trans(mKF),mKF);
utils::add_to_diagonal(DD,mInvVarW);
utils::cholesky_decompose(DD,mD);
vectord vn = mData.mY;
inplace_solve(mL,vn,ublas::lower_tag());
mWMap = prod(mMean.mFeatM,vn) + utils::ublas_elementwise_prod(mInvVarW,mW0);
utils::cholesky_solve(mD,mWMap,ublas::lower());
mVf = mData.mY - prod(trans(mMean.mFeatM),mWMap);
inplace_solve(mL,mVf,ublas::lower_tag());
vectord v0 = mData.mY - prod(trans(mMean.mFeatM),mW0);
//TODO: check for "cheaper" version
//matrixd KK = prod(mL,trans(mL));
matrixd KK = computeCorrMatrix();
matrixd WW = zmatrixd(p,p); //TODO: diagonal matrix
utils::add_to_diagonal(WW,mInvVarW);
const matrixd FW = prod(trans(mMean.mFeatM),WW);
KK += prod(FW,mMean.mFeatM);
matrixd BB(n,n);
utils::cholesky_decompose(KK,BB);
inplace_solve(BB,v0,ublas::lower_tag());
mSigma = (mBeta/mAlpha + inner_prod(v0,v0))/(n+2*mAlpha);
int dof = static_cast<int>(n+2*mAlpha);
if ((boost::math::isnan(mWMap(0))) || (boost::math::isnan(mSigma)))
{
throw std::runtime_error("Error in precomputed prediction. NaN found.");
}
if (dof <= 0)
{
dof = n;
FILE_LOG(logERROR) << "ERROR: Incorrect alpha. Dof invalid."
<< "Forcing Dof <= num of points.";
}
d_->setDof(dof);
}
void GaussianProcess::precomputePrediction()
{
const size_t n = mData.getNSamples();
mAlphaV.resize(n,false);
mAlphaV = mData.mY-mMean.muTimesFeat();
inplace_solve(mL,mAlphaV,ublas::lower_tag());
}
vector<NumericT> solve(const matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> & proxy,
const vector_base<NumericT> & vec,
SOLVERTAG const & tag)
{
// run an inplace solve on the result vector:
vector<NumericT> result(vec);
inplace_solve(proxy, result, tag);
return result;
}
vector<NumericT> solve(const matrix_base<NumericT> & mat,
const vector_base<NumericT> & vec,
SOLVERTAG const & tag)
{
// do an inplace solve on the result vector:
vector<NumericT> result(vec);
inplace_solve(mat, result, tag);
return result;
}
matrix_base<NumericT> solve(const matrix_base<NumericT> & A,
const matrix_base<NumericT> & B,
SOLVERTAG tag)
{
// do an inplace solve on the result vector:
matrix_base<NumericT> result(B);
inplace_solve(A, result, tag);
return result;
}
matrix_base<NumericT> solve(const matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> & proxy_A,
const matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> & proxy_B,
SOLVERTAG tag)
{
// run an inplace solve on the result vector:
matrix_base<NumericT> result(proxy_B);
inplace_solve(proxy_A, result, tag);
return result;
}
matrix<SCALARTYPE, F2, ALIGNMENT_B> solve(const matrix<SCALARTYPE, F1, ALIGNMENT_A> & A,
const matrix<SCALARTYPE, F2, ALIGNMENT_B> & B,
TAG const & tag)
{
// do an inplace solve on the result vector:
matrix<SCALARTYPE, F2, ALIGNMENT_A> result(B.size1(), B.size2());
result = B;
inplace_solve(A, result, tag);
return result;
}
vector<SCALARTYPE, VEC_ALIGNMENT> solve(const matrix<SCALARTYPE, F, ALIGNMENT> & mat,
const vector<SCALARTYPE, VEC_ALIGNMENT> & vec,
TAG const & tag)
{
// do an inplace solve on the result vector:
vector<SCALARTYPE, VEC_ALIGNMENT> result(vec.size());
result = vec;
inplace_solve(mat, result, tag);
return result;
}
vector<SCALARTYPE, VEC_ALIGNMENT> solve(compressed_matrix<SCALARTYPE, MAT_ALIGNMENT> const & L,
const vector<SCALARTYPE, VEC_ALIGNMENT> & vec,
viennacl::linalg::upper_tag const & tag)
{
// do an inplace solve on the result vector:
vector<SCALARTYPE, VEC_ALIGNMENT> result(vec.size());
result = vec;
inplace_solve(L, result, tag);
return result;
}
ProbabilityDistribution* GaussianProcessML::prediction( const vectord &query )
{
double kq = computeSelfCorrelation(query);
vectord kn = computeCrossCorrelation(query);
vectord phi = mMean.getFeatures(query);
vectord v(kn);
inplace_solve(mL,v,ublas::lower_tag());
vectord rq = phi - prod(v,mKF);
vectord rho(rq);
inplace_solve(mL2,rho,ublas::lower_tag());
double yPred = inner_prod(phi,mWML) + inner_prod(v,mAlphaF);
double sPred = sqrt( mSigma * (kq - inner_prod(v,v)
+ inner_prod(rho,rho)));
d_->setMeanAndStd(yPred,sPred);
return d_;
}
double GaussianProcess::negativeLogLikelihood()
{
const matrixd K = computeCorrMatrix();
const size_t n = K.size1();
matrixd L(n,n);
utils::cholesky_decompose(K,L);
vectord alpha(mData.mY-mMean.muTimesFeat());
inplace_solve(L,alpha,ublas::lower_tag());
double loglik = ublas::inner_prod(alpha,alpha)/(2*mSigma);
loglik += utils::log_trace(L);
return loglik;
}
vector<SCALARTYPE, VEC_ALIGNMENT> solve(const matrix_expression< const matrix<SCALARTYPE, F, ALIGNMENT>,
const matrix<SCALARTYPE, F, ALIGNMENT>,
op_trans> & proxy,
const vector<SCALARTYPE, VEC_ALIGNMENT> & vec,
TAG const & tag)
{
// do an inplace solve on the result vector:
vector<SCALARTYPE, VEC_ALIGNMENT> result(vec.size());
result = vec;
inplace_solve(proxy, result, tag);
return result;
}
matrix<SCALARTYPE, F2, ALIGNMENT_B> solve(const matrix_expression< const matrix<SCALARTYPE, F1, ALIGNMENT_A>,
const matrix<SCALARTYPE, F1, ALIGNMENT_A>,
op_trans> & proxy,
const matrix<SCALARTYPE, F2, ALIGNMENT_B> & B,
TAG const & tag)
{
// do an inplace solve on the result vector:
matrix<SCALARTYPE, F2, ALIGNMENT_B> result(B.size1(), B.size2());
result = B;
inplace_solve(proxy, result, tag);
return result;
}
ProbabilityDistribution*
StudentTProcessJeffreys::prediction(const vectord &query )
{
clock_t start = clock();
double kq = computeSelfCorrelation(query);
// vectord kn = computeCrossCorrelation(query);
mKernel.computeCrossCorrelation(mData.mX,query,mKn);
vectord phi = mMean.getFeatures(query);
// vectord v(mKn);
inplace_solve(mL,mKn,ublas::lower_tag());
vectord rho = phi - prod(mKn,mKF);
// vectord rho(rq);
inplace_solve(mL2,rho,ublas::lower_tag());
double yPred = inner_prod(phi,mWML) + inner_prod(mKn,mAlphaF);
double sPred = sqrt( mSigma * (kq - inner_prod(mKn,mKn)
+ inner_prod(rho,rho)));
d_->setMeanAndStd(yPred,sPred);
return d_;
}
ProbabilityDistribution* GaussianProcess::prediction(const vectord &query)
{
const double kq = computeSelfCorrelation(query);
const vectord kn = computeCrossCorrelation(query);
vectord vd(kn);
inplace_solve(mL,vd,ublas::lower_tag());
double basisPred = mMean.muTimesFeat(query);
double yPred = basisPred + ublas::inner_prod(vd,mAlphaV);
double sPred = sqrt(mSigma*(kq - ublas::inner_prod(vd,vd)));
d_->setMeanAndStd(yPred,sPred);
return d_;
}
typename viennacl::enable_if< viennacl::is_any_dense_nonstructured_matrix<M1>::value
&& viennacl::is_any_dense_nonstructured_matrix<M2>::value,
typename detail::extract_embedded_type<M2>::type
>::type
solve(const M1 & A, const M2 & B, SOLVERTAG tag)
{
typedef typename detail::extract_embedded_type<M2>::type MatrixType;
// do an inplace solve on the result vector:
MatrixType result(B);
inplace_solve(A, result, tag);
return result;
}
typename viennacl::enable_if< viennacl::is_any_dense_nonstructured_matrix<M1>::value
&& viennacl::is_any_dense_nonstructured_vector<V1>::value,
typename detail::extract_embedded_type<V1>::type
>::type
solve(const M1 & mat,
const V1 & vec,
SOLVERTAG const & tag)
{
// do an inplace solve on the result vector:
typename detail::extract_embedded_type<V1>::type result(vec);
inplace_solve(mat, result, tag);
return result;
}
typename viennacl::enable_if< viennacl::is_any_dense_nonstructured_matrix<M1>::value
&& viennacl::is_any_dense_nonstructured_matrix<M2>::value,
typename detail::extract_embedded_type<M2>::type
>::type
solve(const matrix_expression< const M1, const M1, op_trans> & proxy_A,
const matrix_expression< const M2, const M2, op_trans> & proxy_B,
SOLVERTAG tag)
{
typedef typename detail::extract_embedded_type<M2>::type MatrixType;
// do an inplace solve on the result vector:
MatrixType result(proxy_B);
inplace_solve(proxy_A, result, tag);
return result;
}
double GaussianProcessNormal::negativeLogLikelihood()
{
matrixd KK = computeCorrMatrix();
const size_t n = KK.size1();
const size_t p = mMean->nFeatures();
vectord v0 = mGPY - prod(trans(mFeatM),mW0);
matrixd WW = zmatrixd(p,p); //TODO: diagonal matrix
utils::addToDiagonal(WW,mInvVarW);
matrixd FW = prod(trans(mFeatM),WW);
KK += prod(FW,mFeatM);
matrixd BB(n,n);
utils::cholesky_decompose(KK,BB);
inplace_solve(BB,v0,ublas::lower_tag());
double zz = inner_prod(v0,v0);
double lik = 1/(2*mSigma) * zz;
lik += utils::log_trace(BB);
return lik;
}
double StudentTProcessNIG::negativeLogLikelihood()
{
matrixd KK = computeCorrMatrix();
const size_t n = KK.size1();
const size_t p = mMean.nFeatures();
const size_t nalpha = (n+2*mAlpha);
vectord v0 = mData.mY - prod(trans(mMean.mFeatM),mW0);
matrixd WW = zmatrixd(p,p); //TODO: diagonal matrix
utils::add_to_diagonal(WW,mInvVarW);
matrixd FW = prod(trans(mMean.mFeatM),WW);
KK += prod(FW,mMean.mFeatM);
matrixd BB(n,n);
utils::cholesky_decompose(KK,BB);
inplace_solve(BB,v0,ublas::lower_tag());
double zz = inner_prod(v0,v0);
double sigmaMap = (mBeta/mAlpha + zz)/nalpha;
double lik = nalpha/2 * std::log(1+zz/(2*mBeta*sigmaMap));
lik += utils::log_trace(BB);
lik += n/2 * std::log(sigmaMap);
return lik;
}
//==========================================================================
// Solver interface
//==========================================================================
template<class XPR> result_type solve(const XPR& b ) const
{
result_type bb = b;
inplace_solve(bb);
return bb;
}
