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]
