MatrixXd compute_empirical_T3(SparseMatrix<double> whitened_data, VectorXd y_mean){
int nx = (int)whitened_data.cols();
//printf("nx = %d\n", nx);
double shift12 = (alpha0 + 1.0)*(alpha0 + 2.0) / (2.0*(double)nx);
double shift01 = -alpha0 *(alpha0 + 1.0) / (2.0*(double)nx);
double shift00 = alpha0*alpha0;
MatrixXd emp_T3_whitened = MatrixXd::Zero(KHID, KHID * KHID);
for(int n=0; n<nx; n++){
VectorXd y = whitened_data.col(n);
MatrixXd temp0, temp1, temp2, temp3, temp4;
temp0.noalias() = shift12 * (y * y.transpose());
temp1.noalias() = shift01 * (y * y.transpose());
temp2.noalias() = shift01 * (y * y_mean.transpose());
temp3.noalias() = shift01 * (y_mean * y.transpose());
temp4.noalias() = shift00 * (y_mean * y_mean.transpose());
for(int i=0; i < KHID; i++){
emp_T3_whitened.block(0,i*KHID, KHID, KHID).noalias() += temp0*y(i);
emp_T3_whitened.block(0,i*KHID, KHID, KHID).noalias() += temp1*y_mean(i);
emp_T3_whitened.block(0,i*KHID, KHID, KHID).noalias() += temp2*y(i);
emp_T3_whitened.block(0,i*KHID, KHID, KHID).noalias() += temp3*y(i);
emp_T3_whitened.block(0,i*KHID, KHID, KHID).noalias() += temp4*y_mean(i);
}
}
return emp_T3_whitened;
}
void DMultivariateGaussian::body(const VectorXd &x )
{
// Look http://en.wikipedia.org/wiki/Multinomial_distribution
double n=x.size();
double value=0.0;
if (isStandard)
{
double factor1 = 1.0/pow(2.0*M_PI,n/2.0);
double factor2 = 1.0/( sqrt(abs(covar.determinant()) ) );
VectorXd dx = x-mean;
RowVectorXd dxt = dx.transpose();
VectorXd x1 = invCovar*dx;
double arg = -0.5* (x1.dot(dxt));
value = factor1*factor2*exp(arg);
}
else
{
double factor1 = 1.0/pow(2.0*M_PI,n/2.0);
double sigma=1.0;
double factor2 = 1.0/sigma;
VectorXd dx = x-mean;
RowVectorXd dxt = dx.transpose();
VectorXd x1 = invCovar*dx;
double arg = -0.5* (x1.dot(dxt));
value = factor1*factor2*exp(arg);
}
result = value;
}
// [[Rcpp::depends(RcppEigen)]]
// [[Rcpp::export]]
MatrixXd gibbsSamplerC(int nMC,
VectorXd y,
MatrixXd X,
double a = 1.1,
double b = 1.1,
double kappa = 0.1) {
int n = X.rows();
int p = X.cols();
VectorXd beta = VectorXd::Zero(p);
MatrixXd Res(nMC, p+1);
// take Cholesky decomposition of M matrix
MatrixXd M = ( kappa * MatrixXd::Identity(p, p) ) + ( X.transpose() * X );
LLT<MatrixXd> lltOfM(M);
MatrixXd L = lltOfM.matrixL();
// to be used in draws of sigmasq estimates
double A = a + 0.5*(n+p);
// to be used in draws of beta estimates
VectorXd beta_means = M.inverse() * (X.transpose() * y);
// run Markov Chain
for ( int i=0; i<nMC; ++i ) {
// UPDATE SIGMASQ ESTIMATE
// update scale parameter
VectorXd mat = y - (X * beta);
double beta_val = (beta.transpose() * beta).sum();
double mat_val = (mat.transpose() * mat).sum();
double B = ( b + 0.5 * kappa * beta_val ) + ( 0.5 * mat_val );
// new sigmasq inverse gamma draw
double gamma_draw = rgamma(1, A, 1/B)[0];
double new_sigmasq = 1.0/gamma_draw;
// UPDATE BETA ESTIMATES
for ( int c=0; c<p; ++c ) {
beta(c) = beta_means(c) + sqrt(new_sigmasq) * L.inverse().sum() * rnorm(1, 0, 1)[0];
}
// STORE RESULTS
Res(i, p) = new_sigmasq;
Res.row(i).leftCols(p) = beta;
}
return Res;
}
double cRBLayer::getEnergy(VectorXd& vNodes){
VectorXd wx_b = vNodes.transpose()*W;
wx_b=wx_b+hb;
double vxb = vNodes.transpose()*vb;
VectorXd ones(h);
ones.setOnes();
wx_b.array().exp();
wx_b+=ones;
wx_b.array().log();
return -wx_b.sum()-vxb;
}
void HmcSampler::_getNextQuadraticHitTime(const VectorXd & a, const VectorXd & b, double & hit_time, int & cn , const bool first_bounce ){
hit_time=0;
double mint;
if (first_bounce) {mint=0;}
else {mint=min_t;}
for (int i=0; i != quadraticConstraints.size(); i++ ){
QuadraticConstraint qc = quadraticConstraints[i];
double q1= - ((a.transpose())*(qc.A))*a;
q1 = q1 + ((b.transpose())*(qc.A))*b;
double q2= (qc.B).dot(b);
double q3= qc.C + a.transpose()*(qc.A)*a;
double q4= 2*b.transpose()*(qc.A)*a;
double q5= (qc.B).dot(a);
double r4 = q1*q1 + q4*q4;
double r3 = 2*q1*q2 + 2*q4*q5;
double r2 = q2*q2 + 2*q1*q3 + q5*q5 -q4*q4;
double r1 = 2*q2*q3 - 2*q4*q5;
double r0= q3*q3 - q5*q5;
double roots[]={0,0,0,0};
double aa = r3/r4;
double bb = r2/r4;
double cc = r1/r4;
double dd = r0/r4;
//Solve quartics of the form x^4 + aa x^3 + bb x^2 + cc x + dd ==0
int sols = quarticSolve(aa, bb, cc, dd, roots[0], roots[1], roots[2], roots[3]);
for (int j=0; j<sols; j++){
double r = roots[j];
if (abs(r) <=1 ){
double l1 = q1*r*r + q2*r + q3;
double l2 = -sqrt(1-r*r)*(q4*r + q5);
if (l1/l2 > 0){
double t = acos(r);
if ( t> mint && (hit_time == 0 || t < hit_time)){
hit_time=t;
cn=i;
}
}
}
}
}
}
void SOGP::reduceBasisVectorSet(unsigned int index) {
unsigned int end = this->current_size-1;
VectorXd zero_vector = VectorXd::Zero(this->current_size);
VectorXd alpha_star = this->alpha.row(index);
VectorXd last_item = this->alpha.row(end);
alpha.block(index,0,1,this->output_dim) = last_item.transpose();
alpha.block(end,0,1, this->output_dim) = VectorXd::Zero(this->output_dim).transpose();
double cstar = this->C(index, index);
VectorXd Cstar = this->C.col(index);
Cstar(index) = Cstar(end);
Cstar.conservativeResize(end);
VectorXd Crep = C.col(end);
Crep(index) = Crep(end);
C.block(index, 0, 1, this->current_size) = Crep.transpose();
C.block(0, index, this->current_size, 1) = Crep;
C.block(end, 0, 1, this->current_size) = zero_vector.transpose();
C.block(0, end, this->current_size,1) = zero_vector;
double qstar = this->Q(index, index);
VectorXd Qstar = this->Q.col(index);
Qstar(index) = Qstar(end);
Qstar.conservativeResize(end);
VectorXd Qrep = Q.col(end);
Qrep(index) = Qrep(end);
Q.block(index, 0, 1, this->current_size) = Qrep.transpose();
Q.block(0, index, this->current_size, 1) = Qrep;
Q.block(end, 0, 1, this->current_size) = zero_vector.transpose();
Q.block(0, end, this->current_size,1) = zero_vector;
VectorXd qc = (Qstar + Cstar)/(qstar + cstar);
for (unsigned int i=0; i<this->output_dim; i++) {
VectorXd diffAlpha = alpha.block(0,i,end,1) - alpha_star(i)*qc;
alpha.block(0,i,end,1) = diffAlpha;
}
MatrixXd oldC = C.block(0,0, end, end);
C.block(0,0, end,end) = oldC + (Qstar*Qstar.transpose())/qstar -
((Qstar + Cstar)*((Qstar + Cstar).transpose()))/(qstar+cstar);
MatrixXd oldQ = Q.block(0,0,end,end);
Q.block(0,0, end, end) = oldQ - (Qstar*Qstar.transpose())/qstar;
this->basis_vectors[index] = this->basis_vectors[end];
this->basis_vectors.pop_back();
this->current_size = end;
}
void SOGP::predict(const VectorXd &state, VectorXd &prediction,
VectorXd &prediction_variance) {
//check if we have initialised the system
if (!this->initialized) {
throw OTLException("SOGP not yet initialised");
}
double kstar = kernel->eval(state,state);
//check if we not been trained
if (this->current_size == 0) {
prediction = VectorXd::Zero(this->output_dim);
prediction_variance = VectorXd::Ones(this->output_dim)*
(kstar + this->noise);
return;
}
VectorXd k;
kernel->eval(state, this->basis_vectors, k);
//std::cout << "K: \n" << k << std::endl;
//std::cout << "alpha: \n" << this->alpha.block(0,0,this->current_size, this->output_dim) << std::endl;
prediction = k.transpose() *this->alpha.block(0,0,this->current_size, this->output_dim);
prediction_variance = VectorXd::Ones(this->output_dim)*
(k.dot(this->C.block(0,0, this->current_size, this->current_size)*k)
+ kstar + this->noise);
return;
}
void parameters::Likelihood(const VectorXd & eff){
VectorXd loc;
loc.resize(m_proba.rows());
loc=(m_proba.rowwise().sum().array().log());
m_loglikelihood=eff.transpose()*loc;
m_bic=m_loglikelihood - 0.5*m_nbparam*log(eff.sum());
}
MatrixXd WishartUnit(int m, int df)
{
MatrixXd c(m,m);
c.setZero();
for ( int i = 0; i < m; i++ ) {
std::gamma_distribution<> gam(0.5*(df - i));
c(i,i) = sqrt(2.0 * gam(rng));
VectorXd r = nrandn(m-i-1);
c.block(i,i+1,1,m-i-1) = r.transpose();
}
MatrixXd ret = c.transpose() * c;
#ifdef TEST_MVNORMAL
cout << "WISHART UNIT {\n" << endl;
cout << " m:\n" << m << endl;
cout << " df:\n" << df << endl;
cout << " ret;\n" << ret << endl;
cout << " c:\n" << c << endl;
cout << "}\n" << ret << endl;
#endif
return ret;
}
void CLogistic::TrainOnevsAll(const Matrix<double, Dynamic, Dynamic, RowMajor>& X, const VectorXd& y_class, int num_labels, double lambda)
{
/*
trains multiple logistic regression classifiers and returns all
the classifiers in a matrix classifier, where the i-th row of classifier
corresponds to the classifier for label i
*/
int m = X.rows();
int n = X.cols();
classifier = Matrix<double, Dynamic, Dynamic, RowMajor>::Zero(num_labels, n);
// Iterate through all the classification classes
for(int class_ndx = 0; class_ndx < num_labels; class_ndx++)
{
VectorXd theta = VectorXd::Zero(n);
// classify one vs. all
VectorXd c = VectorXd::Zero(y_class.rows());
for (int point_ndx = 0; point_ndx < y_class.rows(); point_ndx++)
c(class_ndx) = (y_class(point_ndx) == class_ndx ? 1.0 : .0);
GradientDescent(X, c, theta, lambda);
// store the result inside classifier
classifier.row(class_ndx) = theta.transpose();
}
}
double HmcSampler::_verifyConstraints(const VectorXd & b){
double r =0;
int idx =0;
for (int i=0; i != (int)quadraticConstraints.size(); i++ ){
QuadraticConstraint qc = quadraticConstraints[i];
double check = ((b.transpose())*(qc.A))*b + (qc.B).dot(b) + qc.C;
if (i==0 || check < r) {
r = check;
}
}
for (int i=0; i != (int)linearConstraints.size(); i++ ){
LinearConstraint lc = linearConstraints[i];
double check = (lc.f).dot(b) + lc.g;
if (i==0 || check < r) {
r = check;
idx = i;
}
}
// if (r < 0) {
// LinearConstraint lc = linearConstraints[idx];
// double fpart = (lc.f).dot(b);
// double gpart = lc.g;
// printf("The %ith constraint is negative. fb: %g, g: %g\n", idx, fpart, gpart);
// }
return r;
}
ArrayXd squaredDistsToVectors(const MatrixXd& X, const MatrixXd& V) {
auto prods = -2. * (X * V.transpose());
MatrixXd dists = prods;
VectorXd rowSquaredNorms = X.rowwise().squaredNorm();
VectorXd colSquaredNorms = V.rowwise().squaredNorm();
RowVectorXd colSquaredNormsAsRow = colSquaredNorms.transpose();
dists.colwise() += rowSquaredNorms;
dists.rowwise() += colSquaredNormsAsRow;
// // does the above compute the distances properly? -> yes
// ArrayXd trueDists = ArrayXd(X.rows(), V.rows());
// for (int i = 0; i < X.rows(); i++) {
// for (int j = 0; j < V.rows(); j++) {
// VectorXd diff = X.row(i) - V.row(j);
// trueDists(i, j) = diff.squaredNorm();
// auto gap = fabs(trueDists(i, j) - dists(i, j));
// if (gap > .001) {
// printf("WE'RE COMPUTING THE DISTANCES WRONG!!!");
// }
// assert(gap < .001);
// }
// }
return dists.array();
}
void insertRow(MatrixXd &mat, const VectorXd &row)
{
assert(mat.cols() == row.size());
int rows = mat.rows();
int cols = mat.cols();
mat.noalias() = (MatrixXd(rows+1,cols) << mat, row.transpose()).finished();
}
double evalwa(const VectorXd & a0, const VectorXd & ainf, const vector<MatrixXd> & wa, const vector<int> s) {
RowVectorXd a = a0.transpose();
for (vector<int>::const_iterator it = s.begin(); it != s.end(); it++) {
a *= wa[*it];
}
return a*ainf;
}
int main(int argc, const char * argv[])
{
// insert code here...
int m = 2;
int n = 4;
MatrixXd A(m,n);
VectorXd c(n);
VectorXd b(m);
VectorXd index(m);
/*
A << 4, 3, 1, 0, 0,
2, 3, 0, 1, 0,
4, 2, 0, 0, 1;
c << 9,12,0,0,0;
b << 180, 150, 160;
index<<2,3,4;
*/
A<<-1, 2,1,0,
1,0,0,1;
c<<-1,4,0,0;
b<<30,30;
Simplex sim(A,b,c);
VectorXd sol = sim.SolveLP(1);
index = sim.getIdx();
double J = sim.getZ();
cout<<"the solution is:\n"<<index.transpose()<<endl<<sol.transpose()<<endl;
cout<<"the optimal value is: "<<J<<endl;
return 0;
}
void FunctionApproximatorGPR::train(const MatrixXd& inputs, const MatrixXd& targets)
{
if (isTrained())
{
cerr << "WARNING: You may not call FunctionApproximatorGPR::train more than once. Doing nothing." << endl;
cerr << " (if you really want to retrain, call reTrain function instead)" << endl;
return;
}
assert(inputs.rows() == targets.rows());
assert(inputs.cols()==getExpectedInputDim());
const MetaParametersGPR* meta_parameters_gpr =
dynamic_cast<const MetaParametersGPR*>(getMetaParameters());
double max_covar = meta_parameters_gpr->maximum_covariance();
VectorXd sigmas = meta_parameters_gpr->sigmas();
// Compute the gram matrix
// In a gram matrix, every input point is itself a center
MatrixXd centers = inputs;
// Replicate sigmas, because they are the same for each data point/center
MatrixXd widths = sigmas.transpose().colwise().replicate(centers.rows());
MatrixXd gram(inputs.rows(),inputs.rows());
bool normalize_activations = false;
bool asymmetric_kernels = false;
BasisFunction::Gaussian::activations(centers,widths,inputs,gram,normalize_activations,asymmetric_kernels);
gram *= max_covar;
setModelParameters(new ModelParametersGPR(inputs,targets,gram,max_covar,sigmas));
}
void CMT::STM::initialize(const MatrixXd& input, const MatrixXd& output) {
if(input.rows() != dimIn() || output.rows() != dimOut())
throw Exception("Data has wrong dimensionality.");
if(input.cols() != output.cols())
throw Exception("The number of inputs and outputs should be the same.");
Array<bool, 1, Dynamic> spikes = output.array() > 0.5;
int numSpikes = spikes.sum();
if(numSpikes > dimInNonlinear() && dimInNonlinear() > 0) {
mSharpness = 1.;
MatrixXd inputNonlinear = input.topRows(dimInNonlinear());
MatrixXd inputs1(inputNonlinear.rows(), numSpikes);
MatrixXd inputs0(inputNonlinear.rows(), spikes.size() - numSpikes);
// separate data into spike-triggered and non-spike-triggered stimuli
for(int i = 0, i0 = 0, i1 = 0; i < spikes.size(); ++i)
if(spikes[i])
inputs1.col(i1++) = inputNonlinear.col(i);
else
inputs0.col(i0++) = inputNonlinear.col(i);
// spike-triggered/non-spike-triggered mean and precision
VectorXd m1 = inputs1.rowwise().mean();
VectorXd m0 = inputs0.rowwise().mean();
MatrixXd S1 = covariance(inputs1).inverse();
MatrixXd S0 = covariance(inputs0).inverse();
// parameters of a quadratic model
MatrixXd K = (S0 - S1) / 2.;
VectorXd w = S1 * m1 - S0 * m0;
double p = static_cast<float>(numSpikes) / output.cols();
double a = 0.5 * (m0.transpose() * S0 * m0)(0, 0) - 0.5 * (m1.transpose() * S1 * m1)(0, 0)
+ 0.5 * logDetPD(S1) - 0.5 * logDetPD(S0) + log(p) - log(1. - p)
- log(mNumComponents);
// decompose matrix into eigenvectors
SelfAdjointEigenSolver<MatrixXd> eigenSolver(K);
VectorXd eigVals = eigenSolver.eigenvalues();
MatrixXd eigVecs = eigenSolver.eigenvectors();
VectorXi indices = argSort(eigVals.array().abs());
// use most informative eigenvectors as features
for(int i = 0; i < mNumFeatures && i < indices.size(); ++i) {
int j = indices[i];
mWeights.col(i).setConstant(eigVals[j]);
mFeatures.col(i) = eigVecs.col(j);
}
mWeights = mWeights.array() * (0.5 + 0.5 * ArrayXXd::Random(mNumComponents, mNumFeatures).abs());
mPredictors.rowwise() = w.transpose();
mPredictors += sampleNormal(mNumComponents, mDimInNonlinear).matrix() * log(mNumComponents) / 10.;
mBiases.setConstant(a);
mBiases += VectorXd::Random(mNumComponents) * log(mNumComponents) / 100.;
}
if(dimInLinear() > 0)
mLinearPredictor = input.bottomRows(dimInLinear()) * output.transpose() / numSpikes;
}
int main()
{
int n = 10;
MatrixXd mat(n,2);
for (int i=0; i<n; i++){
mat(i,0) = ((double)random())/RAND_MAX;
mat(i,1) = ((double)random())/RAND_MAX;
}
MatrixXd centered = mat.rowwise() - mat.colwise().mean();
MatrixXd cov = centered.adjoint()*centered;
SelfAdjointEigenSolver<MatrixXd> eig(cov);
MatrixXd ev = eig.eigenvectors();
MatrixXd rotated = ev*mat.transpose();
VectorXd maxCoeff = rotated.rowwise().maxCoeff();
VectorXd minCoeff = rotated.rowwise().minCoeff();
VectorXd center = ev.transpose()*(maxCoeff+minCoeff)/2;
std::cout << "center:" << center.transpose() << std::endl;
std::cout << "rotation:" << ev << std::endl;
std::cout << "extent:"
<< (maxCoeff-minCoeff).transpose() << std::endl;
return 0;
}
void printProblem()
{
printName();
std::cout << std::endl << "A_nodes_: " << std::endl << MatrixXi::Identity(A_nodes_.rows(), A_nodes_.rows()) * A_nodes_ << std::endl << std::endl;
std::cout << "A_: " << std::endl << MatrixXd::Identity(A_.rows(), A_.rows()) * A_ << std::endl << std::endl;
std::cout << "b_: " << std::endl << b_.transpose() << std::endl << std::endl;
}
void CGppe::Approx_CGppe_Laplace(const VectorXd & theta_x, const VectorXd& theta_t, const double& sigma, const MatrixXd& t, const MatrixXd &x, const TypePair & all_pairs,
const VectorXd & idx_global, const VectorXd& idx_global_1, const VectorXd& idx_global_2,
const VectorXd& ind_t, const VectorXd& ind_x, int M, int N)
{
//Parameters function initialization
double eps = 1E-6, psi_new, psi_old;
M = all_pairs.rows();
int n = M * N;
f = VectorXd::Zero(n);
VectorXd fvis = VectorXd::Zero(idx_global.rows());
VectorXd deriv;
double loglike = 0;
covfunc_t->SetTheta(theta_t);
covfunc_x->SetTheta(theta_x);
MatrixXd Kt = covfunc_t->ComputeGrandMatrix(t);
Kx = covfunc_x->ComputeGrandMatrix(x);
MatrixXd K = GetMat(Kt, ind_t, ind_t).array() * GetMat(Kx, ind_x, ind_x).array();
loglike = log_likelihood( sigma, all_pairs, idx_global_1, idx_global_2, M, N);
Kinv = K.inverse();
psi_new = loglike - 0.5 * fvis.transpose() * Kinv * fvis;
psi_old = INT_MIN;
while ((psi_new - psi_old) > eps)
{
psi_old = psi_new;
deriv = deriv_log_likelihood_CGppe_fast( sigma, all_pairs, idx_global_1, idx_global_2, M, N);
W = -deriv2_log_likelihood_CGppe_fast(sigma, all_pairs, idx_global_1, idx_global_2, M, N);
W = GetMat(W, idx_global, idx_global);
llt.compute(W + Kinv);
L = llt.matrixL(); //no need to extract the triangular matrix here
fvis = llt.solve(GetVec(deriv, idx_global) + W * fvis);
for (int w = 0;w < idx_global.rows();w++)
{
f(idx_global(w)) = fvis(w);
}
loglike = log_likelihood( sigma, all_pairs, idx_global_1, idx_global_2, M, N);
psi_new = loglike - 0.5 * fvis.transpose() * Kinv * fvis;
}
}
double drwnGaussian::evaluateSingle(const vector<double>& x) const
{
DRWN_ASSERT(x.size() == (unsigned)_n);
guaranteeInvSigma();
VectorXd z = Eigen::Map<const VectorXd>(&x[0], _n) - _mu;
return -0.5 * (z.transpose() * (*_invSigma) * z)(0) + _logZ;
}
void updateHessian() const
{
MatrixXd& H = *IFunction<PARTIAL_XX>::_val[0];
VectorXd q = static_cast<VectorXd>(x).array().inverse();
H = (x.getSize()*q.array()*q.array()).matrix().asDiagonal();
H -= q*q.transpose(); //Can be optimized by taking into account the symmetry of H and qq'
H *= -getValue(0)/(x.getSize()*x.getSize());
}
double drwnGaussian::evaluateSingle(const VectorXd& x) const
{
DRWN_ASSERT(x.rows() == _n);
guaranteeInvSigma();
VectorXd z = x - _mu;
return -0.5 * (z.transpose() * (*_invSigma) * z)(0) + _logZ;
}
MatrixXd drwnNNGraphLSparseLearner::computeSubGradient()
{
DRWN_FCN_TIC;
MatrixXd G = MatrixXd::Zero(_Lt.rows(), _Lt.cols());
// gradient of \lambda \sum_u \alpha(y_u) \sum_{v \in {\cal N}_u^{+}} d_M(u,v)
drwnNNGraphNodeIndex u(0, 0);
#if 0
for (u.imgIndx = 0; u.imgIndx < _posGraph.numImages(); u.imgIndx++) {
for (u.segId = 0; u.segId < _posGraph[u.imgIndx].numNodes(); u.segId++) {
const drwnNNGraphEdgeList& e = _posGraph[u].edges;
for (drwnNNGraphEdgeList::const_iterator kt = e.begin(); kt != e.end(); ++kt) {
const drwnNNGraphNodeIndex v(kt->targetNode);
const VectorXd delta((_graph[u].features - _graph[v].features).cast<double>());
G += delta * delta.transpose();
}
}
}
G *= _lambda;
#else
G = _lambda * _X;
#endif
// subgradient of \sum_u \alpha(y_u) [\max_{v,w} d_M(u,v) - d_M(u,w) + 1]_{\geq 0}
#ifndef USE_THREADING
DRWN_TODO;
#else
// prepare thread data
const unsigned nJobs = std::min((unsigned)_posGraph.numImages(),
std::max((unsigned)1, drwnThreadPool::MAX_THREADS));
vector<set<unsigned> > imgIndxes(nJobs);
for (unsigned imgIndx = 0; imgIndx < _posGraph.numImages(); imgIndx++) {
imgIndxes[imgIndx % nJobs].insert(imgIndx);
}
// start threads
drwnThreadPool threadPool(nJobs);
threadPool.start();
vector<drwnNNGraphSparseSubGradientThread *> jobs(nJobs);
for (unsigned i = 0; i < nJobs; i++) {
jobs[i] = new drwnNNGraphSparseSubGradientThread(this, &_G, &_updateCache, imgIndxes[i]);
threadPool.addJob(jobs[i]);
}
threadPool.finish();
for (unsigned i = 0; i < jobs.size(); i++) {
delete jobs[i];
}
jobs.clear();
#endif
G += _G;
DRWN_FCN_TOC;
//return 2.0 * _Lt * G;
return (2.0 * _Lt * G).triangularView<Eigen::Upper>();
}
// evaluate (log-likelihood)
void drwnGaussian::evaluate(const MatrixXd& x, VectorXd& p) const
{
DRWN_ASSERT((x.cols() == _n) && (x.rows() == p.rows()));
guaranteeInvSigma();
for (int i = 0; i < x.rows(); i++) {
VectorXd z = x.row(i).transpose() - _mu;
p(i) = -0.5 * (z.transpose() * (*_invSigma) * z)(0) + _logZ;
}
}
void Atimesx(const Matrix & d, const Matrix & a, const Matrix & x, Matrix & Ax)
{
int n=d.size();
Ax=(d.array()*x.array()).matrix();
VectorXd Axcut=Ax.head(n-1);
VectorXd acut = a.head(n-1);
VectorXd xcut = x.head(n-1);
Ax << Axcut + x(n-1)*acut, Ax(n-1)+ acut.transpose()*xcut;
}
void testPCA()
{
VectorXd mu = VectorXd::Zero(5);
MatrixXd sigma(5, 5);
sigma << 0.99100, 0.91660, 1.04247, 0.75531, 0.49842,
0.91660, 2.00318, 1.81101, 0.51745, 1.00774,
1.04247, 1.81101, 2.09615, 0.55339, 1.36639,
0.75531, 0.51745, 0.55339, 0.67500, 0.15996,
0.49842, 1.00774, 1.36639, 0.15996, 1.16316;
drwnPCA pca(drwnSuffStats(1.0, mu, sigma));
pca.dump();
drwnXMLDoc xml;
drwnXMLNode *node = drwnAddXMLChildNode(xml, "test", NULL, false);
pca.save(*node);
drwnXMLNode* child = node->first_node("translation");
VectorXd translation;
drwnXMLUtils::deserialize(*child, translation);
cout << translation.transpose() << endl;
child = node->first_node("projection");
MatrixXd projection;
drwnXMLUtils::deserialize(*child, projection);
cout << projection << endl;
sigma = projection * sigma * projection.transpose();
drwnPCA pca2(drwnSuffStats(1.0, mu, sigma));
xml.clear();
node = drwnAddXMLChildNode(xml, "test", NULL, false);
pca2.save(*node);
child = node->first_node("translation");
drwnXMLUtils::deserialize(*child, translation);
cout << translation.transpose() << endl;
child = node->first_node("projection");
drwnXMLUtils::deserialize(*child, projection);
cout << projection << endl;
}
double ObjectiveMLSSparse::eval(const VectorXd& x) const
{
VectorXd vals = -x.transpose() * (*A_);
double obj = 0.0;
for(int i = 0; i < vals.rows(); ++i)
obj -= logsig(vals(i) - (*b_)(i));
obj /= (double)A_->cols();
return obj;
}
void drwnGaussian::evaluate(const vector<vector<double> >& x, vector<double>& p) const
{
DRWN_ASSERT(x.size() == p.size());
guaranteeInvSigma();
for (unsigned i = 0; i < x.size(); i++) {
DRWN_ASSERT(x[i].size() == (unsigned)_n);
VectorXd z = Eigen::Map<const VectorXd>(&x[i][0], _n) - _mu;
p[i] = -0.5 * (z.transpose() * (*_invSigma) * z)(0) + _logZ;
}
}
// Implements Equation S12 in the Supplementary
MatrixXd expected_dissimilarities(const MatrixXd &J, const MatrixXd &M, const VectorXd &W) {
int n = J.rows();
int o = J.cols();
VectorXd JW = J*W.head(o);
VectorXd u_n = VectorXd::Ones(n);
MatrixXd Delta = J*resistance_distance(M,o)*J.transpose();
Delta.noalias() += 0.5*JW*u_n.transpose();
Delta.noalias() += 0.5*u_n*JW.transpose();
Delta.diagonal() -= JW;
return (Delta);
}