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()); }
void DRSM::set_xnames(const std::vector<std::string> &xnames) { if (xnames.size() != state_dimension()) { std::ostringstream err; err << "Error in DRSM::set_xnames." << endl << "The size of xnames is " << xnames.size() << endl << "But ncol(X) is " << state_dimension() << endl; report_error(err.str()); } xnames_ = xnames; }
//====================================================================== void ArStateModel::set_initial_state_mean(const Vector &mu) { if (mu.size() != state_dimension()) { std::ostringstream err; err << "Attempt to set mu to the wrong size in " "ArStateModel::set_initial_state_mean." << std::endl << " Required size: " << state_dimension() << std::endl << "Supplied argument: " << mu.size() << std::endl; report_error(err.str()); } initial_state_mean_ = mu; }
// TODO(stevescott): test void ASSR::simulate_initial_state(VectorView state0)const { // First, simulate the initial state of the client state vector. VectorView client_state(state0, 0, state0.size()-2); StateSpaceModelBase::simulate_initial_state(client_state); // Next simulate the initial value of the first latent weekly // observation. double mu = StateSpaceModelBase::observation_matrix(0).dot(client_state); state0[state_dimension() - 2] = rnorm(mu, regression_->sigma()); // Finally, the initial state of the cumulator variable is zero. state0[state_dimension() - 1] = 0; }
//====================================================================== Vector ArStateModel::initial_state_mean()const{ if (initial_state_mean_.size() != state_dimension()) { report_error("mu_.size() != state_dimension() in " "ArStateModel::initial_state_mean()"); } return initial_state_mean_; }
TrigStateModel::TrigStateModel(double period, const Vector &frequencies) : IndependentMvnModel(2 * frequencies.size()), period_(period), frequencies_(frequencies), state_transition_matrix_(new IdentityMatrix(state_dimension())), state_variance_matrix_(new DiagonalMatrixBlock(state_dimension())), variance_is_current_(false) { if (frequencies_.empty()) { report_error("At least one frequency needed to initialize TrigStateModel."); } for (int i = 0; i < frequencies_.size(); ++i) { frequencies_[i] = 2 * Constants::pi * frequencies_[i] / period_; } set_mu(Vector(state_dimension(), 0)); }
//====================================================================== void ArStateModel::set_initial_state_variance(const SpdMatrix &Sigma){ if(Sigma.nrow() != state_dimension()){ report_error("attempt to set Sigma to the wrong size in " "ArStateModel::set_initial_state_mean"); } initial_state_variance_ = Sigma; }
//====================================================================== void ArStateModel::set_initial_state_mean(const Vector &mu){ if(mu.size() != state_dimension()){ report_error("attempt to set mu to the wrong size in " "ArStateModel::set_initial_state_mean"); } initial_state_mean_ = mu; }
void TrigStateModel::set_initial_state_variance( const SpdMatrix &variance) { if (nrow(variance) != state_dimension()) { report_error("initial_state_variance is the wrong size " "in TrigStateModel."); } initial_state_variance_ = variance; }
SparseVector TrigStateModel::observation_matrix(int t) const { Vector trig(state_dimension()); for (int i = 0; i < frequencies_.size(); ++i) { trig[2 * i] = cos(frequencies_[i] * t); trig[2 * i + 1] = sin(frequencies_[i] * t); } return SparseVector(trig); }
//====================================================================== SpdMatrix ArStateModel::initial_state_variance()const{ if (initial_state_variance_.nrow() != state_dimension()) { report_error("Sigma_.nrow() != state_dimension() in " "ArStateModel::initial_state_mean()"); } SpdMatrix & Sigma(const_cast<SpdMatrix &>(initial_state_variance_)); if (stationary_initial_distribution_) { Vector gamma = autocovariance(state_dimension()); Sigma.diag() = gamma[0]; for(int i = 1; i < state_dimension(); ++i){ Sigma.superdiag(i) = gamma[i]; } Sigma.reflect(); } return initial_state_variance_; }
// TODO(stevescott): check this SparseVector ASSR::observation_matrix(int t)const { Ptr<FineNowcastingData> fine_data(this->fine_data(t)); int p = state_dimension(); SparseVector ans(p); ans[p-1] = 1; ans[p-2] = fine_data->fraction_in_initial_period(); return ans; }
SparseVector RWHSM::observation_matrix(int t)const{ Date now = time_zero_ + t; SparseVector ans(state_dimension()); if(holiday_->active(now)){ Date holiday_date(holiday_->nearest(now)); int position = now - holiday_->earliest_influence(holiday_date); ans[position] = 1.0; } return ans; }
Vec ASSR::simulate_state_error(int t)const { int state_dim = state_dimension(); Vec ans(state_dim, 0); VectorView client_state_error(ans, 0, state_dim - 2); client_state_error = StateSpaceModelBase::simulate_state_error(t); // TODO(stevescott): check this ans[state_dim - 2] = StateSpaceModelBase::observation_matrix(t).dot(client_state_error) + rnorm(0, regression_->sigma()); ans.back() = 0; return ans; }
/** * \copydoc ProcessModelInterface::predict_state */ virtual State predict_state(double delta_time, const State& state, const Noise& noise, const Input& input) { State prediction = State(state_dimension(), 1); predict_state<sizeof...(Models)>( models_, delta_time, state, noise, input, prediction); return prediction; }
// | V0 Z^T*V0 0 | // | V0*Z Z^T*V0*Z 0 | // | 0 0 0 | Spd ASSR::initial_state_variance()const { Spd V0 = StateSpaceModelBase::initial_state_variance(); SparseVector Z0(StateSpaceModelBase::observation_matrix(0)); Vec covariance = V0 * Z0; double y_variance = Z0.dot(covariance) + regression_->sigsq(); int state_dim = state_dimension(); Spd ans(state_dim, 0.0); SubMatrix upper_left(ans, 0, state_dim - 3, 0, state_dim - 3); upper_left = V0; ans.col(state_dim - 2); VectorView covariance_column(ans.col(state_dim - 2), 0, state_dim - 2 ); VectorView covariance_row(ans.row(state_dim - 2), 0, state_dim - 2 ); covariance_column = covariance; covariance_row = covariance; ans(state_dim - 2, state_dim -2) = y_variance; return ans; }
// Update the sufficient statistics for the regression component of // the model. void ASSR::observe_data_given_state(int t) { const ConstVectorView alpha(state(t)); int state_dim = state_dimension(); const ConstVectorView client_state_error(alpha, 0, state_dim - 2); double y = alpha[state_dim - 2]; // y is the imputed fine-scale observation from the Kalman filter. Ptr<RegressionData> dp(regression_->dat()[t]); // The state_mean is computed using the observation_matrix from // the client model, available from StateSpaceModelBase. double state_mean = StateSpaceModelBase::observation_matrix(t).dot(client_state_error); // We want y with time series effects subtracted off. We get this // by computing state_mean (which contains the full prediction of // y given all state, including the regressors), computing the // residual from state_mean, and adding in the regression effect // back in. double residual = y - state_mean; double predicted = regression_->predict(dp->x()); regression_->suf()->add_mixture_data(residual + predicted, dp->x(), 1.0); }
void TrigStateModel::set_initial_state_mean(const Vector &mean) { if (mean.size() != state_dimension()) { report_error("Initial state mean is the wrong size for TrigStateModel."); } initial_state_mean_ = mean; }
//====================================================================== void ArStateModel::simulate_state_error(RNG &rng, VectorView eta, int t) const { assert(eta.size() == state_dimension()); eta = 0; eta[0] = rnorm_mt(rng) * sigma(); }
Vec ASSR::simulate_initial_state()const { Vec ans(state_dimension()); simulate_initial_state(VectorView(ans)); return ans; }
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; }