protected double evaluate(Likelihood likelihood, Prior prior) {
double logPosterior = 0.0;
if (prior != null) {
final double logPrior = prior.getLogPrior(likelihood.getModel());
if (logPrior == Double.NEGATIVE_INFINITY) {
return Double.NEGATIVE_INFINITY;
}
logPosterior += logPrior;
}
final double logLikelihood = likelihood.getLogLikelihood();
if (Double.isNaN(logLikelihood)) {
return Double.NEGATIVE_INFINITY;
}
// System.err.println("** " + logPosterior + " + " + logLikelihood +
// " = " + (logPosterior + logLikelihood));
logPosterior += logLikelihood;
return logPosterior;
}
public Model getModel() {
return likelihood.getModel();
}
/**
* Run the chain for a given number of states.
*
* @param length number of states to run the chain.
* <p>param onTheFlyOperatorWeights
*/
public long runChain(long length, boolean disableCoerce /*,int onTheFlyOperatorWeights*/) {
likelihood.makeDirty();
currentScore = evaluate(likelihood, prior);
long currentState = currentLength;
final Model currentModel = likelihood.getModel();
if (currentState == 0) {
initialScore = currentScore;
bestScore = currentScore;
fireBestModel(currentState, currentModel);
}
if (currentScore == Double.NEGATIVE_INFINITY) {
// identify which component of the score is zero...
if (prior != null) {
double logPrior = prior.getLogPrior(likelihood.getModel());
if (logPrior == Double.NEGATIVE_INFINITY) {
throw new IllegalArgumentException(
"The initial model is invalid because one of the priors has zero probability.");
}
}
String message = "The initial likelihood is zero";
if (likelihood instanceof CompoundLikelihood) {
message += ": " + ((CompoundLikelihood) likelihood).getDiagnosis();
} else {
message += "!";
}
throw new IllegalArgumentException(message);
}
pleaseStop = false;
isStopped = false;
String diagnostic = "";
// int otfcounter = onTheFlyOperatorWeights > 0 ? onTheFlyOperatorWeights : 0;
double[] logr = {0.0};
boolean usingFullEvaluation = true;
// set ops count in mcmc element instead
if (fullEvaluationCount == 0) // Temporary solution until full code review
usingFullEvaluation = false;
boolean fullEvaluationError = false;
while (!pleaseStop && (currentState < (currentLength + length))) {
// periodically log states
fireCurrentModel(currentState, currentModel);
if (pleaseStop) {
isStopped = true;
break;
}
// Get the operator
final int op = schedule.getNextOperatorIndex();
final MCMCOperator mcmcOperator = schedule.getOperator(op);
double oldScore = currentScore;
// assert Profiler.startProfile("Store");
// The current model is stored here in case the proposal fails
if (currentModel != null) {
currentModel.storeModelState();
}
// assert Profiler.stopProfile("Store");
boolean operatorSucceeded = true;
double hastingsRatio = 1.0;
boolean accept = false;
logr[0] = -Double.MAX_VALUE;
try {
// The new model is proposed
// assert Profiler.startProfile("Operate");
if (DEBUG) {
System.out.println("\n&& Operator: " + mcmcOperator.getOperatorName());
}
if (mcmcOperator instanceof GeneralOperator) {
hastingsRatio = ((GeneralOperator) mcmcOperator).operate(prior, likelihood);
} else {
hastingsRatio = mcmcOperator.operate();
}
// assert Profiler.stopProfile("Operate");
} catch (OperatorFailedException e) {
operatorSucceeded = false;
}
double score = 0.0;
double deviation = 0.0;
// System.err.print("" + currentState + ": ");
if (operatorSucceeded) {
// The new model is proposed
// assert Profiler.startProfile("Evaluate");
if (DEBUG) {
System.out.println("** Evaluate");
}
long elapsedTime = 0;
if (PROFILE) {
elapsedTime = System.currentTimeMillis();
}
// The new model is evaluated
score = evaluate(likelihood, prior);
if (PROFILE) {
mcmcOperator.addEvaluationTime(System.currentTimeMillis() - elapsedTime);
}
// assert Profiler.stopProfile("Evaluate");
if (usingFullEvaluation) {
// This is a test that the state is correctly restored. The
// restored state is fully evaluated and the likelihood compared with
// that before the operation was made.
likelihood.makeDirty();
final double testScore = evaluate(likelihood, prior);
if (Math.abs(testScore - score) > EVALUATION_TEST_THRESHOLD) {
Logger.getLogger("error")
.severe(
"State was not correctly calculated after an operator move.\n"
+ "Likelihood evaluation: "
+ score
+ "\nFull Likelihood evaluation: "
+ testScore
+ "\n"
+ "Operator: "
+ mcmcOperator
+ " "
+ mcmcOperator.getOperatorName());
fullEvaluationError = true;
}
}
if (score > bestScore) {
bestScore = score;
fireBestModel(currentState, currentModel);
}
accept =
mcmcOperator instanceof GibbsOperator
|| acceptor.accept(oldScore, score, hastingsRatio, logr);
deviation = score - oldScore;
}
// The new model is accepted or rejected
if (accept) {
if (DEBUG) {
System.out.println(
"** Move accepted: new score = " + score + ", old score = " + oldScore);
}
mcmcOperator.accept(deviation);
currentModel.acceptModelState();
currentScore = score;
// if( otfcounter > 0 ) {
// --otfcounter;
// if( otfcounter == 0 ) {
// adjustOpWeights(currentState);
// otfcounter = onTheFlyOperatorWeights;
// }
// }
if (usingFullEvaluation) {
oldScore = score; // for the usingFullEvaluation test
diagnostic =
likelihood instanceof CompoundLikelihood
? ((CompoundLikelihood) likelihood).getDiagnosis()
: "";
}
} else {
if (DEBUG) {
System.out.println(
"** Move rejected: new score = " + score + ", old score = " + oldScore);
}
mcmcOperator.reject();
// assert Profiler.startProfile("Restore");
currentModel.restoreModelState();
}
// assert Profiler.stopProfile("Restore");
if (usingFullEvaluation) {
// This is a test that the state is correctly restored. The
// restored state is fully evaluated and the likelihood compared with
// that before the operation was made.
likelihood.makeDirty();
final double testScore = evaluate(likelihood, prior);
final String d2 =
likelihood instanceof CompoundLikelihood
? ((CompoundLikelihood) likelihood).getDiagnosis()
: "";
if (Math.abs(testScore - oldScore) > EVALUATION_TEST_THRESHOLD) {
final Logger logger = Logger.getLogger("error");
logger.severe(
"State was not correctly restored after reject step.\n"
+ "Likelihood before: "
+ oldScore
+ " Likelihood after: "
+ testScore
+ "\n"
+ "Operator: "
+ mcmcOperator
+ " "
+ mcmcOperator.getOperatorName()
+ (diagnostic.length() > 0
? "\n\nDetails\nBefore: " + diagnostic + "\nAfter: " + d2
: ""));
fullEvaluationError = true;
}
}
if (!disableCoerce && mcmcOperator instanceof CoercableMCMCOperator) {
coerceAcceptanceProbability((CoercableMCMCOperator) mcmcOperator, logr[0]);
}
if (usingFullEvaluation) {
if (schedule.getMinimumAcceptAndRejectCount() >= minOperatorCountForFullEvaluation
&& currentState >= fullEvaluationCount) {
// full evaluation is only switched off when each operator has done a
// minimum number of operations (currently 1) and fullEvalationCount
// operations in total.
usingFullEvaluation = false;
if (fullEvaluationError) {
// If there has been an error then stop with an error
throw new RuntimeException(
"One or more evaluation errors occurred during the test phase of this\n"
+ "run. These errors imply critical errors which may produce incorrect\n"
+ "results.");
}
}
}
fireEndCurrentIteration(currentState);
currentState += 1;
}
currentLength = currentState;
return currentLength;
}