double EEMS::test_prior(const MatrixXd &mSeeds, const VectorXd &mEffcts, const double mrateMu,
const MatrixXd &qSeeds, const VectorXd &qEffcts,
const double df, const double sigma2, const double mrateS2, const double qrateS2) const {
bool inrange = true;
int qtiles = qEffcts.size();
int mtiles = mEffcts.size();
// First check that all parameters fall into their support range
for ( int i = 0 ; i < qtiles ; i++ ) {
if (!habitat.in_point(qSeeds(i,0),qSeeds(i,1))) { inrange = false; }
}
for ( int i = 0 ; i < mtiles ; i++ ) {
if (!habitat.in_point(mSeeds(i,0),mSeeds(i,1))) { inrange = false; }
}
if (qEffcts.cwiseAbs().minCoeff()>params.qEffctHalfInterval) { inrange = false; }
if (mEffcts.cwiseAbs().minCoeff()>params.mEffctHalfInterval) { inrange = false; }
if (abs(mrateMu)>params.mrateMuHalfInterval) { inrange = false; }
if ((df<params.dfmin) || (df>params.dfmax)) { inrange = false; }
if (!inrange) { return (-Inf); }
// Then compute the prior, on the log scale
double logpi = - log(df)
+ dnegbinln(mtiles,params.negBiSize,params.negBiProb)
+ dnegbinln(qtiles,params.negBiSize,params.negBiProb)
+ dinvgamln(mrateS2,params.mrateShape_2,params.mrateScale_2)
+ dinvgamln(qrateS2,params.qrateShape_2,params.qrateScale_2)
+ dmvnormln(mEffcts,VectorXd::Zero(mtiles),mrateS2*MatrixXd::Identity(mtiles,mtiles))
+ dmvnormln(qEffcts,VectorXd::Zero(qtiles),qrateS2*MatrixXd::Identity(qtiles,qtiles))
+ dinvgamln(sigma2,params.sigmaShape_2,params.sigmaScale_2);
return (logpi);
}
double computeMerit(double& delta, StdVectorX& X, StdVectorU& U, double penalty_coeff) {
double merit = computeObjective(delta, X, U);
for(int t = 0; t < T-1; ++t) {
VectorXd hval = dynamics_difference(continuous_cartpole_dynamics, X[t], X[t+1], U[t], delta);
merit += penalty_coeff*(hval.cwiseAbs()).sum();
}
return merit;
}
void CostCalculator_eigen::calculateCost(const real_1d_array &xWeight, double &func, real_1d_array &grad) {
for (int i = 0; i < variableNumber_; ++i) xReal_(i) = xWeight[i];
// risk grad
VectorXd riskGrad = varMatrix_ * xReal_;
// weight change
VectorXd weightChange = xReal_ - currentWeight_;
func = 0.5 * xReal_.dot(riskGrad) + weightChange.cwiseAbs().dot(tradingCost_) - expectReturn_.dot(xReal_);
VectorXd tmp = riskGrad + weightChange.cwiseSign().cwiseProduct(tradingCost_) - expectReturn_;
for (int i = 0; i < variableNumber_; ++i) grad(i) = tmp(i);
}
void coxph_reg::estimate(const coxph_data &cdatain,
const int model,
const std::vector<std::string> &modelNames,
const int interaction, const int ngpreds,
const bool iscox, const int nullmodel,
const mlinfo &snpinfo, const int cursnp)
{
coxph_data cdata = cdatain.get_unmasked_data();
mematrix<double> X = t_apply_model(cdata.X, model, interaction, ngpreds,
iscox, nullmodel);
int length_beta = X.nrow;
beta.reinit(length_beta, 1);
sebeta.reinit(length_beta, 1);
mematrix<double> newoffset = cdata.offset -
(cdata.offset).column_mean(0);
mematrix<double> means(X.nrow, 1);
for (int i = 0; i < X.nrow; i++)
{
beta[i] = 0.;
}
mematrix<double> u(X.nrow, 1);
mematrix<double> imat(X.nrow, X.nrow);
double *work = new double[X.ncol * 2 +
2 * (X.nrow) * (X.nrow) +
3 * (X.nrow)];
double loglik_int[2];
int flag;
// Use Efron method of handling ties (for Breslow: 0.0), like in
// R's coxph()
double sctest = 1.0;
// Set the maximum number of iterations that coxfit2() will run to
// the default value from the class definition.
int maxiterinput = MAXITER;
// Make separate variables epsinput and tolcholinput that are not
// const to send to coxfit2(), this way we won't have to alter
// that function (which is a good thing: we want to keep it as
// pristine as possible because it is copied from the R survival
// package).
double epsinput = EPS;
double tolcholinput = CHOLTOL;
coxfit2(&maxiterinput, &cdata.nids, &X.nrow, cdata.stime.data.data(),
cdata.sstat.data.data(), X.data.data(), newoffset.data.data(),
cdata.weights.data.data(), cdata.strata.data.data(),
means.data.data(), beta.data.data(), u.data.data(),
imat.data.data(), loglik_int, &flag, work, &epsinput,
&tolcholinput, &sctest);
// After coxfit2() maxiterinput contains the actual number of
// iterations that were used. Store it in niter.
niter = maxiterinput;
// Check the results of the Cox fit; mirrored from the same checks
// in coxph.fit.S and coxph.R from the R survival package.
// A vector to indicate for which covariates the betas/se_betas
// should be set to NAN.
std::vector<bool> setToNAN = std::vector<bool>(X.nrow, false);
// Based on coxph.fit.S lines with 'which.sing' and coxph.R line
// with if(any(is.NA(coefficients))). These lines set coefficients
// to NA if flag < nvar (with nvar = ncol(x)) and MAXITER >
// 0. coxph.R then checks for any NAs in the coefficients and
// outputs the warning message if NAs were found.
if (flag < X.nrow)
{
int which_sing = 0;
MatrixXd imateigen = imat.data;
VectorXd imatdiag = imateigen.diagonal();
for (int i = 0; i < imatdiag.size(); i++)
{
if (imatdiag[i] == 0)
{
which_sing = i;
setToNAN[which_sing] = true;
if (i != 0) {
// Don't warn for i=0 to exclude the beta
// coefficient for the (constant) mean from the
// check. For Cox regression the constant terms
// are ignored. However, we leave it in the
// calculations because otherwise the null model
// calculation will fail in case there are no
// other covariates than the SNP.
std::cerr << "Warning for " << snpinfo.name[cursnp]
<< ", model " << modelNames[model]
<< ": X matrix deemed to be singular (variable "
<< which_sing + 1 << ")" << std::endl;
}
}
}
}
if (niter >= MAXITER)
{
cerr << "Warning for " << snpinfo.name[cursnp]
<< ", model " << modelNames[model]
<< ": nr of iterations > the maximum (" << MAXITER << "): "
<< niter << endl;
}
if (flag == 1000)
{
cerr << "Warning for " << snpinfo.name[cursnp]
<< ", model " << modelNames[model]
<< ": Cox regression ran out of iterations and did not converge,"
<< " setting beta and se to 'NaN'\n";
std::fill(setToNAN.begin(), setToNAN.end(), true);
} else {
VectorXd ueigen = u.data;
MatrixXd imateigen = imat.data;
VectorXd infs = ueigen.transpose() * imateigen;
infs = infs.cwiseAbs();
VectorXd betaeigen = beta.data;
assert(betaeigen.size() == infs.size());
// We check the beta's for all coefficients
// (incl. covariates), maybe stick to only checking the SNP
// coefficient?
for (int i = 0; i < infs.size(); i++) {
if (infs[i] > EPS &&
infs[i] > sqrt(EPS) * abs(betaeigen[i])) {
setToNAN[i] = true;
cerr << "Warning for " << snpinfo.name[cursnp]
<< ", model " << modelNames[model]
<< ": beta for covariate " << i + 1 << " may be infinite,"
<< " setting beta and se to 'NaN'\n";
}
}
}
for (int i = 0; i < X.nrow; i++)
{
if (setToNAN[i])
{
// Cox regression failed somewhere, set results to NAN for
// this X row (covariate or SNP)
sebeta[i] = NAN;
beta[i] = NAN;
loglik = NAN;
} else {
sebeta[i] = sqrt(imat.get(i, i));
loglik = loglik_int[1];
}
}
delete[] work;
}
size_t UPGMpp::messagesLBP(CGraph &graph,
TInferenceOptions &options,
vector<vector<VectorXd> > &messages ,
bool maximize,
const vector<size_t> &tree)
{
const vector<CNodePtr> nodes = graph.getNodes();
const vector<CEdgePtr> edges = graph.getEdges();
multimap<size_t,CEdgePtr> edges_f = graph.getEdgesF();
size_t N_nodes = nodes.size();
size_t N_edges = edges.size();
bool is_tree = (tree.size()>0) ? true : false;
//graph.computePotentials();
//
// Build the messages structure
//
double totalSumOfMsgs = 0;
if ( !messages.size() )
messages.resize( N_edges);
for ( size_t i = 0; i < N_edges; i++ )
{
if ( !messages[i].size() )
{
messages[i].resize(2);
size_t ID1, ID2;
edges[i]->getNodesID(ID1,ID2);
// Messages from first node of the edge to the second one, so the size of
// the message has to be the same as the number of classes of the second node.
double N_classes = graph.getNodeWithID( ID2 )->getPotentials( options.considerNodeFixedValues ).rows();
messages[i][0].resize( N_classes );
messages[i][0].fill(1.0/N_classes);
// Just the opposite as before.
N_classes = graph.getNodeWithID( ID1 )->getPotentials( options.considerNodeFixedValues ).rows();
messages[i][1].resize( N_classes );
messages[i][1].fill(1.0/N_classes);
}
totalSumOfMsgs += messages[i][0].rows() + messages[i][1].rows();
}
// cout << "Initial Messages:" << endl;
// for ( size_t i=0; i < messages.size(); i++)
// for ( size_t j=0; j < messages[i].size(); j++)
// for ( size_t k=0; k < messages[i][j].size(); k++ )
// cout << messages[i][j][k] << " ";
vector<vector<VectorXd> > previousMessages;
if ( options.particularS["order"] == "RBP" )
{
previousMessages = messages;
for ( size_t i = 0; i < previousMessages.size(); i++ )
{
previousMessages[i][0].fill(0);
previousMessages[i][1].fill(0);
}
}
//
// Iterate until convergence or a certain maximum number of iterations is reached
//
size_t iteration;
// cout << endl;
for ( iteration = 0; iteration < options.maxIterations; iteration++ )
{
// cout << "Messages " << iteration << ":" << endl;
// for ( size_t i=0; i < messages.size(); i++)
// for ( size_t j=0; j < messages[i].size(); j++)
// for ( size_t k=0; k < messages[i][j].size(); k++ )
// cout << messages[i][j][k] << " ";
// cout << endl;
// Variables used by Residual Belief Propagation
int edgeWithMaxDiffIndex = -1;
VectorXd associatedMessage;
bool from1to2;
double maxDifference = -1;
//
// Iterate over all the nodes
//
for ( size_t nodeIndex = 0; nodeIndex < N_nodes; nodeIndex++ )
{
const CNodePtr nodePtr = graph.getNode( nodeIndex );
size_t nodeID = nodePtr->getID();
// Check if we are calibrating a tree, and so if the node is not member of the tree,
// so we dont have to update its messages
if ( is_tree && ( std::find(tree.begin(), tree.end(), nodeID ) == tree.end() ) )
continue;
NEIGHBORS_IT neighbors;
neighbors = edges_f.equal_range(nodeID);
//cout << " Sending messages ... " << endl;
//
// Send a message to each neighbor
//
for ( multimap<size_t,CEdgePtr>::iterator itNeigbhor = neighbors.first;
itNeigbhor != neighbors.second;
itNeigbhor++ )
{
// cout << "sending msg to neighbor..." << endl;
VectorXd nodePotPlusIncMsg = nodePtr->getPotentials( options.considerNodeFixedValues );
// cout << "nodePotPlusIncMsg Orig: " << nodePotPlusIncMsg.transpose() << endl;
size_t neighborID;
size_t ID1, ID2;
CEdgePtr edgePtr( (*itNeigbhor).second );
edgePtr->getNodesID(ID1,ID2);
( ID1 == nodeID ) ? neighborID = ID2 : neighborID = ID1;
// cout << "all ready" << endl;
// Check if we are calibrating a tree, and so if the neighbor node
// is not member of the tree, so we dont have to update its messages
if ( is_tree && ( std::find(tree.begin(), tree.end(), neighborID ) == tree.end() ))
continue;
//
// Compute the message from current node as a product of all the
// incoming messages less the one from the current neighbor
// plus the node potential of the current node.
//
for ( multimap<size_t,CEdgePtr>::iterator itNeigbhor2 = neighbors.first;
itNeigbhor2 != neighbors.second;
itNeigbhor2++ )
{
size_t ID11, ID12;
CEdgePtr edgePtr2( (*itNeigbhor2).second );
edgePtr2->getNodesID(ID11,ID12);
size_t edgeIndex = graph.getEdgeIndex( edgePtr2->getID() );
// cout << "Edge index: " << edgeIndex << endl << "node pot" << nodePotPlusIncMsg << endl;
// cout << "Node ID: " << nodeID << " node11 " << ID11 << " node12 " << ID12 << endl;
CNodePtr n1,n2;
edgePtr2->getNodes(n1,n2);
// cout << "Node 1 type: " << n1->getType()->getID() << " label " << n1->getType()->getLabel() << endl;
// cout << "Node 2 type: " << n2->getType()->getID() << " label " << n2->getType()->getLabel() << endl;
// Check if the current neighbor appears in the edge
if ( ( neighborID != ID11 ) && ( neighborID != ID12 ) )
{
if ( nodeID == ID11 )
{
// cout << "nodePotPlusIncMsg Prod: " << messages[ edgeIndex ][ 1 ].transpose() << endl;
// cout << "nodePotPlusIncMsg Bis : " << messages[ edgeIndex ][ 0 ].transpose() << endl;
nodePotPlusIncMsg =
nodePotPlusIncMsg.cwiseProduct(messages[ edgeIndex ][ 1 ]);
// cout << "nodePotPlusIncMsg Prod2: " << nodePotPlusIncMsg.transpose() << endl;
}
else // nodeID == ID2
{
// cout << "nodePotPlusIncMsg Prod: " << messages[ edgeIndex ][ 0 ].transpose() << endl;
// cout << "nodePotPlusIncMsg Bis : " << messages[ edgeIndex ][ 1 ].transpose() << endl;
nodePotPlusIncMsg =
nodePotPlusIncMsg.cwiseProduct(messages[ edgeIndex ][ 0 ]);
// cout << "nodePotPlusIncMsg Prod2: " << nodePotPlusIncMsg.transpose() << endl;
}
}
}
// cout << "Node pot" << endl;
//cout << "Node pot" << nodePotPlusIncMsg << endl;
//
// Take also the potential between the two nodes
//
MatrixXd edgePotentials;
if ( nodeID != ID1 )
edgePotentials = edgePtr->getPotentials();
else
edgePotentials = edgePtr->getPotentials().transpose();
VectorXd newMessage;
size_t edgeIndex = graph.getEdgeIndex( edgePtr->getID() );
// cout << "get new message" << endl;
if ( !maximize )
{
// Multiply both, and update the potential
// cout << "Edge potentials:" << edgePotentials.transpose() << endl;
// cout << "nodePotPlusIncMsg:" << nodePotPlusIncMsg.transpose() << endl;
newMessage = edgePotentials * nodePotPlusIncMsg;
// Normalize new message
if (newMessage.sum())
newMessage = newMessage / newMessage.sum();
//cout << "New message 3:" << newMessage.transpose() << endl;
}
else
{
if ( nodeID == ID1 )
newMessage.resize(messages[ edgeIndex ][0].rows());
else
newMessage.resize(messages[ edgeIndex ][1].rows());
for ( size_t row = 0; row < edgePotentials.rows(); row++ )
{
double maxRowValue = std::numeric_limits<double>::min();
for ( size_t col = 0; col < edgePotentials.cols(); col++ )
{
double value = edgePotentials(row,col)*nodePotPlusIncMsg(col);
if ( value > maxRowValue )
maxRowValue = value;
}
newMessage(row) = maxRowValue;
}
// Normalize new message
if (newMessage.sum())
newMessage = newMessage / newMessage.sum();
//cout << "New message: " << endl << newMessage << endl;
}
//
// Set the message!
//
VectorXd smoothedOldMessage(newMessage.rows());
smoothedOldMessage.setZero();
double smoothing = options.particularD["smoothing"];
if ( smoothing != 0 )
if ( nodeID == ID1 )
newMessage = newMessage + (1-smoothing) * messages[ edgeIndex ][0];
else
newMessage = newMessage + (1-smoothing) * messages[ edgeIndex ][1];
//cout << "New message:" << endl << newMessage << endl << "Smoothed" << endl << smoothedOldMessage << endl;
// If residual belief propagation is activated, just check if the
// newMessage is the one with the higest residual till the
// moment. Otherwise, set the new message as the current one
if ( options.particularS["order"] == "RBP" )
{
if ( nodeID == ID1 )
{
VectorXd differences = messages[edgeIndex][0] - newMessage;
double difference = differences.cwiseAbs().sum();
if ( difference > maxDifference )
{
from1to2 = true;
edgeWithMaxDiffIndex = edgeIndex;
maxDifference = difference;
associatedMessage = newMessage;
}
}
else
{
VectorXd differences = messages[edgeIndex][1] - newMessage;
double difference = differences.cwiseAbs().sum();
if ( difference > maxDifference )
{
from1to2 = false;
edgeWithMaxDiffIndex = edgeIndex;
maxDifference = difference;
associatedMessage = newMessage;
}
}
}
else
{
// cout << newMessage.cols() << " " << newMessage.rows() << endl;
// cout << "edgeIndex" << edgeIndex << endl;
if ( nodeID == ID1 )
{
// cout << messages[ edgeIndex ][0].cols() << " " << messages[ edgeIndex ][0].rows() << endl;
messages[ edgeIndex ][0] = newMessage;
}
else
{
// cout << messages[ edgeIndex ][1].cols() << " " << messages[ edgeIndex ][1].rows() << endl;
messages[ edgeIndex ][1] = newMessage;
}
// cout << "Wop " << endl;
}
}
} // Nodes
if ( options.particularS["order"] == "RBP" && ( edgeWithMaxDiffIndex =! -1 ))
{
if ( from1to2 )
messages[ edgeWithMaxDiffIndex ][0] = associatedMessage;
else
messages[ edgeWithMaxDiffIndex ][1] = associatedMessage;
}
//
// Check convergency!!
//
double newTotalSumOfMsgs = 0;
for ( size_t i = 0; i < N_edges; i++ )
{
newTotalSumOfMsgs += messages[i][0].sum() + messages[i][1].sum();
}
//printf("%4.10f\n",std::abs( totalSumOfMsgs - newTotalSumOfMsgs ));
if ( std::abs( totalSumOfMsgs - newTotalSumOfMsgs ) <
options.convergency )
break;
totalSumOfMsgs = newTotalSumOfMsgs;
// Show messages
/*cout << "Iteration:" << iteration << endl;
for ( size_t i = 0; i < messages.size(); i++ )
{
cout << messages[i][0] << " " << messages[i][1] << endl;
}*/
} // Iterations
return 1;
}
