void MarkovExpectation::compute(FitContext *fc, const char *what, const char *how)
{
if (fc) {
for (auto c1 : components) {
c1->compute(fc, what, how);
}
}
omxRecompute(initial, fc);
if (initialV != omxGetMatrixVersion(initial)) {
omxCopyMatrix(scaledInitial, initial);
EigenVectorAdaptor Ei(scaledInitial);
if (scale == SCALE_SOFTMAX) Ei.derived() = Ei.array().exp();
if (scale != SCALE_NONE) {
Ei /= Ei.sum();
}
if (verbose >= 2) mxPrintMat("initial", Ei);
initialV = omxGetMatrixVersion(initial);
}
if (transition) {
omxRecompute(transition, fc);
if (transitionV != omxGetMatrixVersion(transition)) {
omxCopyMatrix(scaledTransition, transition);
EigenArrayAdaptor Et(scaledTransition);
if (scale == SCALE_SOFTMAX) Et.derived() = Et.array().exp();
if (scale != SCALE_NONE) {
Eigen::ArrayXd v = Et.colwise().sum();
Et.rowwise() /= v.transpose();
}
if (verbose >= 2) mxPrintMat("transition", Et);
transitionV = omxGetMatrixVersion(transition);
}
}
}
static int getLatentVersion(BA81Expect *state)
{
int vv = 1; // to ensure it doesn't match on the first test
if (state->_latentMeanOut) vv += omxGetMatrixVersion(state->_latentMeanOut);
if (state->_latentCovOut) vv += omxGetMatrixVersion(state->_latentCovOut);
return vv;
}
static void
ba81compute(omxExpectation *oo, FitContext *fc, const char *what, const char *how)
{
BA81Expect *state = (BA81Expect *) oo->argStruct;
if (what) {
if (strcmp(what, "latentDistribution")==0 && how && strcmp(how, "copy")==0) {
omxCopyMatrix(state->_latentMeanOut, state->estLatentMean);
omxCopyMatrix(state->_latentCovOut, state->estLatentCov);
double sampleSizeAdj = (state->weightSum - 1.0) / state->weightSum;
int covSize = state->_latentCovOut->rows * state->_latentCovOut->cols;
for (int cx=0; cx < covSize; ++cx) {
state->_latentCovOut->data[cx] *= sampleSizeAdj;
}
return;
}
if (strcmp(what, "scores")==0) {
state->expectedUsed = true;
state->type = EXPECTATION_AUGMENTED;
} else if (strcmp(what, "nothing")==0) {
state->type = EXPECTATION_OBSERVED;
} else {
omxRaiseErrorf("%s: don't know how to predict '%s'",
oo->name, what);
}
if (state->verbose >= 1) {
mxLog("%s: predict %s", oo->name, what);
}
return;
}
bool latentClean = state->latentParamVersion == getLatentVersion(state);
bool itemClean = state->itemParamVersion == omxGetMatrixVersion(state->itemParam) && latentClean;
ba81NormalQuad &quad = state->getQuad();
if (state->verbose >= 1) {
mxLog("%s: Qinit %d itemClean %d latentClean %d (1=clean) expectedUsed=%d",
oo->name, (int)quad.isAllocated(), itemClean, latentClean, state->expectedUsed);
}
if (!latentClean) {
ba81RefreshQuadrature(oo);
state->latentParamVersion = getLatentVersion(state);
}
if (!itemClean) {
double *param = state->EitemParam? state->EitemParam : state->itemParam->data;
state->grp.quad.cacheOutcomeProb(param, FALSE);
bool estep = state->expectedUsed;
if (estep) {
if (oo->dynamicDataSource) {
BA81Engine<BA81Expect*, BA81LatentSummary, BA81Estep> engine;
engine.ba81Estep1(&state->grp, state);
} else {
BA81Engine<BA81Expect*, BA81LatentFixed, BA81Estep> engine;
engine.ba81Estep1(&state->grp, state);
}
} else {
state->grp.quad.releaseEstep();
refreshPatternLikelihood(state, oo->dynamicDataSource);
}
if (oo->dynamicDataSource && state->verbose >= 2) {
mxLog("%s: empirical distribution mean and cov:", state->name);
omxPrint(state->estLatentMean, "mean");
omxPrint(state->estLatentCov, "cov");
}
if (state->verbose >= 1) {
const int numUnique = state->getNumUnique();
mxLog("%s: estep<%s, %s> %d/%d rows excluded",
state->name,
(estep && oo->dynamicDataSource? "summary":"fixed"),
(estep? "estep":"omitEstep"),
state->grp.excludedPatterns, numUnique);
}
}
state->itemParamVersion = omxGetMatrixVersion(state->itemParam);
}
