void StateModel::simulate_initial_state(VectorView eta)const{
if(eta.size() != state_dimension()){
std::ostringstream err;
err << "output vector 'eta' has length " << eta.size()
<< " in StateModel::simulate_initial_state. Expected length "
<< state_dimension();
report_error(err.str());
}
eta = rmvn(initial_state_mean(), initial_state_variance());
}
Vec ArModel::simulate(int n) const {
int p = number_of_lags();
Vec acf = autocovariance(p);
Spd Sigma(p);
Sigma.diag() = acf[0];
for(int i = 1; i < p; ++i) {
Sigma.subdiag(i) = acf[i];
Sigma.superdiag(i) = acf[i];
}
Vec zero(p, 0.0);
Vec y0 = rmvn(zero, Sigma);
return simulate(n, y0);
}
Vector ArModel::simulate(int n, RNG &rng) const {
int p = number_of_lags();
Vector acf = autocovariance(p);
SpdMatrix Sigma(p);
Sigma.diag() = acf[0];
for (int i = 1; i < p; ++i) {
Sigma.subdiag(i) = acf[i];
Sigma.superdiag(i) = acf[i];
}
Vector zero(p, 0.0);
Vector y0 = rmvn(zero, Sigma);
return simulate(n, y0, rng);
}
Vector StateSpaceLogitModel::one_step_holdout_prediction_errors(
RNG &rng,
BinomialLogitDataImputer &data_imputer,
const Vector &successes,
const Vector &trials,
const Matrix &predictors,
const Vector &final_state) {
if (nrow(predictors) != successes.size()
|| trials.size() != successes.size()) {
report_error("Size mismatch in arguments provided to "
"one_step_holdout_prediction_errors.");
}
Vector ans(successes.size());
int t0 = dat().size();
ScalarKalmanStorage ks(state_dimension());
ks.a = *state_transition_matrix(t0 - 1) * final_state;
ks.P = SpdMatrix(state_variance_matrix(t0 - 1)->dense());
// This function differs from the Gaussian case because the
// response is on the binomial scale, and the state model is on
// the logit scale. Because of the nonlinearity, we need to
// incorporate the uncertainty about the forecast in the
// prediction for the observation. We do this by imputing the
// latent logit and its mixture indicator for each observation.
// The strategy is (for each observation)
// 1) simulate next state.
// 2) simulate w_t given state
// 3) kalman update state given w_t.
for (int t = 0; t < ans.size(); ++t) {
bool missing = false;
Vector state = rmvn(ks.a, ks.P);
double state_contribution = observation_matrix(t+t0).dot(state);
double regression_contribution =
observation_model_->predict(predictors.row(t));
double mu = state_contribution + regression_contribution;
double prediction = trials[t] * plogis(mu);
ans[t] = successes[t] - prediction;
// ans[t] is a random draw of the one step ahead prediction
// error at time t0+t given observed data to time t0+t-1. We
// now proceed with the steps needed to update the Kalman filter
// so we can compute ans[t+1].
double precision_weighted_sum, total_precision;
std::tie(precision_weighted_sum, total_precision) = data_imputer.impute(
rng,
trials[t],
successes[t],
mu);
double latent_observation = precision_weighted_sum / total_precision;
double latent_variance = 1.0 / total_precision;
// The latent state was drawn from its predictive distribution
// given Y[t0 + t -1] and used to impute the latent data for
// y[t0+t]. That latent data is now used to update the Kalman
// filter for the next time period. It is important that we
// discard the imputed state at this point.
sparse_scalar_kalman_update(latent_observation - regression_contribution,
ks.a,
ks.P,
ks.K,
ks.F,
ks.v,
missing,
observation_matrix(t + t0),
latent_variance,
*state_transition_matrix(t + t0),
*state_variance_matrix(t + t0));
}
return ans;
}
