def test(): size = 10 ########## # specify parameters random_state = np.random.RandomState(0) transition_matrix = [[1, 0.1], [0, 1]] transition_offset = [-0.1, 0.1] observation_matrix = np.eye(2) + random_state.randn(2, 2) * 0.1 observation_offset = [1.0, -1.0] transition_covariance = np.eye(2) observation_covariance = np.eye(2) + random_state.randn(2, 2) * 0.1 initial_state_mean = [5, -5] initial_state_covariance = [[1, 0.1], [-0.1, 1]] # sample from model kf = KalmanFilter(transition_matrix, observation_matrix, transition_covariance, observation_covariance, transition_offset, observation_offset, initial_state_mean, initial_state_covariance, random_state=random_state) states, observations = kf.sample(n_timesteps=size, initial_state=initial_state_mean) print(states) print(states[:, 0])
def simulate(self, n_obs=100, random_seed=None): """ Given a calibrate or estimated model, simulates values of the endogenous variables based on random samples of the exogenous shocks. :param n_obs: number of observation in the time dimension. :param random_seed: random seed for the simulation. :return: pandas DataFrame. 'df_obs' contains the simualtions for the observable variables. 'df_state' contains the simulations for the state/endogenous variables. """ # TODO se não tiver equações de observações, retornar None para o 'df_obs' assert self.has_solution, "No solution was generated yet" if not (random_seed is None): seed(random_seed) kf = KalmanFilter(self.G1, self.obs_matrix, self.impact @ self.impact.T, None, self.C_out.reshape(self.n_state), self.obs_offset.reshape(self.n_obs)) simul_data = kf.sample(n_obs) state_names = [str(s) for s in list(self.endog)] obs_names = [f'obs {i+1}' for i in range(self.obs_matrix.shape[0])] df_obs = pd.DataFrame(data=simul_data[1], columns=obs_names) df_states = pd.DataFrame(data=simul_data[0], columns=state_names) return df_obs, df_states
def KalmanSequence(size, a): # a = transition matrix's (0,0) and (1,1) coordinate ########## # specify parameters random_state = np.random.RandomState(0) transition_matrix = [[a, 0], [0, a]] transition_offset = [0, 0] observation_matrix = np.eye(2) #+ random_state.randn(2, 2) * 0.1 observation_offset = [0, 0] transition_covariance = np.eye(2) observation_covariance = np.eye(2) #+ random_state.randn(2, 2) * 0.1 initial_state_mean = [5, -5] initial_state_covariance = [[1, 0], [0, 1]] # sample from model kf = KalmanFilter( transition_matrix, observation_matrix, transition_covariance, observation_covariance, transition_offset, observation_offset, initial_state_mean, initial_state_covariance, random_state=random_state ) states, observations = kf.sample(n_timesteps=size, initial_state=initial_state_mean) # estimate state with filtering and smoothing filtered_state_estimates = kf.filter(observations)[0] # smoothed_state_estimates = kf.smooth(observations)[0] return states, observations, filtered_state_estimates
def test_kalman_sampling(): kf = KalmanFilter( data.transition_matrix, data.observation_matrix, data.transition_covariance, data.observation_covariance, data.transition_offsets, data.observation_offset, data.initial_state_mean, data.initial_state_covariance) (x, z) = kf.sample(100) assert_true(x.shape == (100, data.transition_matrix.shape[0])) assert_true(z.shape == (100, data.observation_matrix.shape[0]))
def KalmanSequence(size, a, rand): # X_{t+1} = a*X_t + noise ########## # specify parameters random_state = np.random.RandomState(rand) transition_matrix = [[a]] transition_offset = [0] observation_matrix = np.eye(1) #+ random_state.randn(2, 2) * 0.1 observation_offset = [0] transition_covariance = np.eye(1) observation_covariance = np.eye(1) #+ random_state.randn(2, 2) * 0.1 initial_state_mean = [0] initial_state_covariance = [[1]] # for 2-dim # random_state = np.random.RandomState(0) # transition_matrix = [[a, 0], [0, a]] # transition_offset = [0, 0] # observation_matrix = np.eye(2) #+ random_state.randn(2, 2) * 0.1 # observation_offset = [0, 0] # transition_covariance = np.eye(2) # observation_covariance = np.eye(2) #+ random_state.randn(2, 2) * 0.1 # initial_state_mean = [5, -5] # initial_state_covariance = [[1, 0], [0, 1]] # sample from model kf = KalmanFilter( transition_matrix, observation_matrix, transition_covariance, observation_covariance, transition_offset, observation_offset, initial_state_mean, initial_state_covariance, random_state=random_state ) states, observations = kf.sample(n_timesteps=size, initial_state=initial_state_mean) # estimate state with filtering and smoothing filtered_state_estimates = kf.filter(states)[0] # filtered_state_estimates = kf.filter(observations)[0] # smoothed_state_estimates = kf.smooth(observations)[0] return states, observations, filtered_state_estimates
transition_covariance = np.eye(2) observation_covariance = np.eye(2) + random_state.randn(2, 2) * 0.1 initial_state_mean = [5, -5] initial_state_covariance = [[1, 0.1], [-0.1, 1]] # sample from model kf = KalmanFilter(transition_matrix, observation_matrix, transition_covariance, observation_covariance, transition_offset, observation_offset, initial_state_mean, initial_state_covariance, random_state=random_state) states, observations = kf.sample(n_timesteps=50, initial_state=initial_state_mean) # estimate state with filtering and smoothing filtered_state_estimates = kf.filter(observations)[0] smoothed_state_estimates = kf.smooth(observations)[0] # draw estimates pl.figure() lines_true = pl.plot(states[:, 0], states[:, 1], color='b') #lines_filt = pl.plot(filtered_state_estimates, color='r') lines_smooth = pl.plot(smoothed_state_estimates[:, 0], smoothed_state_estimates[:, 1], color='g') pl.legend((lines_true[0], lines_smooth[0]), ('true', 'smooth'), loc='lower right') pl.show()
random_state = np.random.RandomState(0) transition_matrix = [[1, 0.1], [0, 1]] transition_offset = [-0.1, 0.1] observation_matrix = np.eye(2) + random_state.randn(2, 2) * 0.1 observation_offset = [1.0, -1.0] initial_state_mean = [5, -5] n_timesteps = 50 #%% # sample from model kf = KalmanFilter(transition_matrices=transition_matrix, observation_matrices=observation_matrix, transition_offsets=transition_offset, observation_offsets=observation_offset, initial_state_mean=initial_state_mean, random_state=0) states, observations_all = kf.sample(n_timesteps, initial_state=initial_state_mean) #%% # label half of the observations as missing observations_missing = np.ma.array(observations_all, mask=np.zeros(observations_all.shape)) for t in range(n_timesteps): if t % 5 != 0: observations_missing[t] = np.ma.masked #%% observations_missing #%% # estimate state with filtering and smoothing smoothed_states_all = kf.smooth(observations_all)[0] smoothed_states_missing = kf.smooth(observations_missing)[0] #%%
''' Step 1: Provide a de facto system ''' A = np.array([[1, T, 0.5 * T * T], [0, 1, T], [0, 0, 1]]) B = [0, 0, 0] C = [1, 0, 0] D = [0] Q = 0.01 * np.eye(3) R = 0.005 * np.eye(1) m0 = [0, 0, 0.1] P0 = 0.1 * np.eye(3) kft = KalmanFilter(A, C, Q, R, B, D, m0, P0, random_state=random_state) # model should be state, observation = kft.sample(n_timesteps=step, initial_state=m0) # provide data #filtered_state_estimatet, f_covt = kft.filter(observation) #smoothed_state_estimatet, s_covt = kft.smooth(observation) ''' Step 2: Initialize our model ''' # specify parameters transition_matrix = A transition_offset = B observation_matrix = C observation_offset = D transition_covariance = 0.02 * np.eye(3) observation_covariance = np.eye(1) initial_state_mean = [0, 0, 1] initial_state_covariance = 5 * np.eye(3)
def main(argv): config = read_parser(argv, Inputs, InputsOpt_Defaults) if config['mode'] == 'normal': print('nothing') n = 500 x_pure = np.arange(n) * 0.1 x = x_pure + np.random.normal(scale=0.25, size=n) y = np.cos(x) # y = 2*x+ 6 kf = KalmanFilter(initial_state_mean=0, n_dim_obs=1, random_state=1) # measurements = [[x[i], y[i]] for i in range(int(n))] measurements = [[y[i]] for i in range(int(n / 2))] # measurements_full = [[y[i]] for i in range(int(n))] kf.em(measurements) # print(kf.initial_state_mean) # print(kf.initial_state_covariance) # print(type(kf.initial_state_mean)) # print(type(kf.initial_state_covariance)) # exit() z = kf.filter(measurements) means = z[0] covs = z[1] it_mean = means[len(means) - 1] it_cov = covs[len(covs) - 1] h = list(means) r = h # kf2 = KalmanFilter(initial_state_mean=it_mean, initial_state_covariance=it_cov, n_dim_obs=1) # kf2.em(measurements) f = list( kf.sample(int(n / 2), initial_state=it_mean, random_state=1)[0]) # f = h + list(np.array(f) + it_mean) f = h + f for i in range(int(n / 2)): it_z = kf.filter_update(filtered_state_mean=it_mean, filtered_state_covariance=it_cov, observation=[y[i + int(n / 2)]]) it_mean = it_z[0] it_cov = it_z[1] h.append(it_mean) plt.plot(x_pure, h, 'r') plt.plot(x_pure, y) plt.plot(x_pure, f, 'g') plt.show() elif config['mode'] == 'ukalman': print('Ukalman') n = 1000 x_pure = np.arange(n) * 0.1 x = x_pure + np.random.normal(scale=0.5, size=n) y = np.cos(x) # y = 2*x kf = AdditiveUnscentedKalmanFilter(n_dim_obs=1) measurements = [[y[i]] for i in range(int(n / 2))] kf.initial_state_mean = np.array([0.]) kf.initial_state_covariance = np.array([[0.1]]) it_mean = kf.initial_state_mean it_cov = kf.initial_state_covariance print(kf.initial_state_mean) print(kf.initial_state_covariance) # exit() h = [] for element in measurements: it_z = kf.filter_update(filtered_state_mean=it_mean, filtered_state_covariance=it_cov, observation=element) it_mean = it_z[0] it_cov = it_z[1] h.append(it_mean) f = list(kf.sample(int(n / 2), initial_state=it_mean)[0]) # f = h + list(np.array(f) + it_mean) f = h + f plt.plot(x_pure, y) plt.plot(x_pure, f, 'g') plt.show() return
transition_offset = [-0.1, 0.1] observation_matrix = np.eye(2) + random_state.randn(2, 2) * 0.1 observation_offset = [1.0, -1.0] transition_covariance = np.eye(2) observation_covariance = np.eye(2) + random_state.randn(2, 2) * 0.1 initial_state_mean = [5, -5] initial_state_covariance = [[1, 0.1], [-0.1, 1]] kf = KalmanFilter( transition_matrix, observation_matrix, transition_covariance, observation_covariance, transition_offset, observation_offset, initial_state_mean, initial_state_covariance, random_state=random_state ) states, observations = kf.sample( n_timesteps=50, initial_state=initial_state_mean ) # sample from model kf = KalmanFilter( transition_matrix, observation_matrix, transition_covariance, observation_covariance, transition_offset, observation_offset, initial_state_mean, initial_state_covariance, random_state=random_state, em_vars=[ 'transition_matrices', 'observation_matrices', 'transition_covariance', 'observation_covariance', 'observation_offsets', 'initial_state_mean', 'initial_state_covariance' ] )
observation_matrix = np.eye(2) + random_state.randn(2, 2) * 0.1 observation_offset = [1.0, -1.0] initial_state_mean = [5, -5] n_timesteps = 50 # sample from model kf = KalmanFilter( transition_matrices=transition_matrix, observation_matrices=observation_matrix, transition_offsets=transition_offset, observation_offsets=observation_offset, initial_state_mean=initial_state_mean, random_state=0 ) states, observations_all = kf.sample( n_timesteps, initial_state=initial_state_mean ) # label half of the observations as missing observations_missing = np.ma.array( observations_all, mask=np.zeros(observations_all.shape) ) for t in range(n_timesteps): if t % 5 != 0: observations_missing[t] = np.ma.masked # estimate state with filtering and smoothing smoothed_states_all = kf.smooth(observations_all)[0] smoothed_states_missing = kf.smooth(observations_missing)[0]