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; }
Ptr<SparseMatrixBlock> DRSM::state_error_variance(int t) const { return state_variance_matrix(t); }