def Run_ParticleFilter(sampled_data,para,
x_process_noise_sigma=0.05,beta_process_noise_sigma=0.005,gamma_process_noise_sigma=0.05,
sensor_std_err = .1,
x_init_gauss_sigma=0.1,beta_init_gauss_sigma=0.5,gamma_init_gauss_sigma=0.5,
x_init_uniform_bound=0.1,beta_init_uniform_bound=0.1,gamma_init_uniform_bound=0.1,
len_prognostic=1500,num_particles=2000,len_learn=1000,
sta_fun_kind='linear'):
t=np.arange(0,1001,0.5)
t_real=t[0:len_prognostic]
show_particle_index=np.arange(0,len_learn+40,30)
# t_real = sampled_data[0:len_prognostic,0]
x_obs= sampled_data[0:len_prognostic,1]
if sta_fun_kind=='linear':
para_0=para[0][4]
para_beta=para[1][4,:]
x_init_range=np.array([x_obs[0]-x_init_uniform_bound,x_obs[0]+x_init_uniform_bound])
beta_init_range=np.array([para_0-beta_init_uniform_bound,para_0+beta_init_uniform_bound])
x_init_gauss=np.array([x_obs[0],x_init_gauss_sigma])
beta_init_gauss=np.array([para_0,beta_init_gauss_sigma])
pf = PF_C.ParticleFilter(num_particles, x_range=x_init_range,
beta_range=beta_init_range,gamma_range=[-1,1],
measure_std_error=sensor_std_err)
pf.create_gaussian_particles(x_init_gauss,beta_init_gauss,[0,1])
x_particle=[]
beta_particle=[]
x_mu_filtered=[]
x_var_filtered=[]
beta_mu_filtered=[]
beta_var_filtered=[]
for x in range(len_prognostic):
#learn phase
if x <= len_learn:
zs =x_obs[x]
pf.predict_linear(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
pf.update(z=zs)
# indexes = PF_C.residual_resample2(pf.weights)
# pf.resample_from_index(indexes)
pf.resample()
result=pf.estimate()
#prognostics phase
elif x > len_learn:
pf.prognosis_linear(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
result=pf.estimate()
x_mu_filtered.append(result[0])
x_var_filtered.append(result[1])
beta_mu_filtered.append(result[2])
beta_var_filtered.append(result[3])
x_particle.append(pf.particles[:,0])
beta_particle.append(pf.particles[:,1])
x_particle=np.array(x_particle)
beta_particle=np.array(beta_particle)
plt.figure()
plt.subplot(2,1,1)
# plot the learn phase data
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],x_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0,dashes=[10, 6, 1, 6, 1, 6])
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],x_obs[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],x_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
#plot the threshold
plt_th.plot_threshold(sampled_data_FC=sampled_data)
# plt.ylim(3.1,3.5)
# plt.plot(t_real[show_particle_index],x_particle[show_particle_index],'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('voltage')
plt.title('linear')
plt.legend(['observation','real data','filter'])
plt.subplot(2,1,2)
# # plot the learn phase data
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],beta_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_beta[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],beta_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
plt.plot(t_real[show_particle_index],beta_particle[show_particle_index],'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('parameter - beta')
plt.xlim(0,1200)
plt.ylim(-0.016,0.012)
plt.legend(['observation','real data','filter'])
elif sta_fun_kind=='exp':
para_0=para[0][0]
para_beta=para[1][0,:]
x_init_range=np.array([x_obs[0]-x_init_uniform_bound,x_obs[0]+x_init_uniform_bound])
beta_init_range=np.array([para_0-beta_init_uniform_bound,para_0+beta_init_uniform_bound])
x_init_gauss=np.array([x_obs[0],x_init_gauss_sigma])
beta_init_gauss=np.array([para_0,beta_init_gauss_sigma])
pf = PF_C.ParticleFilter(num_particles, x_range=x_init_range,
beta_range=beta_init_range,gamma_range=[-1,1],
measure_std_error=sensor_std_err)
pf.create_gaussian_particles(x_init_gauss,beta_init_gauss,[0,1])
x_particle=[]
beta_particle=[]
x_mu_filtered=[]
x_var_filtered=[]
beta_mu_filtered=[]
beta_var_filtered=[]
for x in range(len_prognostic):
#learn phase
if x <= len_learn:
zs =x_obs[x]
pf.predict_exp(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
pf.update(z=zs)
# indexes = PF_C.residual_resample2(pf.weights)
# pf.resample_from_index(indexes)
pf.resample()
result=pf.estimate()
#prognostics phase
elif x > len_learn:
pf.prognosis_exp(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
result=pf.estimate()
x_mu_filtered.append(result[0])
x_var_filtered.append(result[1])
beta_mu_filtered.append(result[2])
beta_var_filtered.append(result[3])
x_particle.append(pf.particles[:,0])
beta_particle.append(pf.particles[:,1])
plt.figure()
plt.subplot(2,1,1)
# plot the learn phase data
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],x_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0,dashes=[10, 6, 1, 6, 1, 6])
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],x_obs[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],x_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
#plot the threshold
plt_th.plot_threshold(sampled_data_FC=sampled_data)
# plt.ylim(3.1,3.5)
# plt.plot(t_real[0:iterations],x_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('voltage')
plt.title('exp')
plt.legend(['observation','real data','filter'])
plt.subplot(2,1,2)
# # plot the learn phase data
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],beta_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_beta[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],beta_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
# plt.plot(t_real[0:iterations],beta_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('parameter - beta')
plt.xlim(0,1200)
plt.legend(['observation','real data','filter'])
elif sta_fun_kind=='ln':
para_0=para[0][1]
para_beta=para[1][1,:]
x_init_range=np.array([x_obs[0]-x_init_uniform_bound,x_obs[0]+x_init_uniform_bound])
beta_init_range=np.array([para_0-beta_init_uniform_bound,para_0+beta_init_uniform_bound])
x_init_gauss=np.array([x_obs[0],x_init_gauss_sigma])
beta_init_gauss=np.array([para_0,beta_init_gauss_sigma])
pf = PF_C.ParticleFilter(num_particles, x_range=x_init_range,
beta_range=beta_init_range,gamma_range=[-1,1],
measure_std_error=sensor_std_err)
pf.create_gaussian_particles(x_init_gauss,beta_init_gauss,[0,1])
x_particle=[]
beta_particle=[]
x_mu_filtered=[]
x_var_filtered=[]
beta_mu_filtered=[]
beta_var_filtered=[]
for x in range(len_prognostic):
#learn phase
if x <= len_learn:
zs =x_obs[x]
pf.predict_ln(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
pf.update(z=zs)
# indexes = PF_C.residual_resample2(pf.weights)
# pf.resample_from_index(indexes)
pf.resample()
result=pf.estimate()
#prognostics phase
elif x > len_learn:
pf.prognosis_ln(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
result=pf.estimate()
x_mu_filtered.append(result[0])
x_var_filtered.append(result[1])
beta_mu_filtered.append(result[2])
beta_var_filtered.append(result[3])
x_particle.append(pf.particles[:,0])
beta_particle.append(pf.particles[:,1])
x_particle=np.array(x_particle)
beta_particle=np.array(beta_particle)
plt.figure()
plt.subplot(2,1,1)
# plot the learn phase data
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],x_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0,dashes=[10, 6, 1, 6, 1, 6])
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],x_obs[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],x_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
#plot the threshold
plt_th.plot_threshold(sampled_data_FC=sampled_data)
# plt.ylim(3.1,3.5)
# plt.plot(t_real[0:iterations],x_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time/hours')
plt.ylabel('voltage/v')
plt.title('ln')
plt.legend(['observation','real data','filter'])
plt.subplot(2,1,2)
# # plot the learn phase data
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],beta_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_beta[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],beta_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
# plt.plot(t_real[0:iterations],beta_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('parameter - beta')
plt.xlim(0,1200)
plt.legend(['observation','real data','filter'])
elif sta_fun_kind=='ln_l':
para_0=para[0][2]
para_1=para[0][3]
para_beta=para[1][2,:]
para_gamma=para[1][3,:]
x_init_range=np.array([x_obs[0]-x_init_uniform_bound,x_obs[0]+x_init_uniform_bound])
beta_init_range=np.array([para_0-beta_init_uniform_bound,para_0+beta_init_uniform_bound])
gamma_init_range=np.array([para_1-gamma_init_uniform_bound,para_1+gamma_init_uniform_bound])
x_init_gauss=np.array([x_obs[0],x_init_gauss_sigma])
beta_init_gauss=np.array([para_0,beta_init_gauss_sigma])
gamma_init_gauss=np.array([para_1,gamma_init_gauss_sigma])
pf = PF_C.ParticleFilter(num_particles, x_range=x_init_range,
beta_range=beta_init_range,gamma_range=gamma_init_range,
measure_std_error=sensor_std_err)
pf.create_gaussian_particles(x_init_gauss,beta_init_gauss,gamma_init_gauss)
x_particle=[]
beta_particle=[]
gamma_particle=[]
x_mu_filtered=[]
x_var_filtered=[]
beta_mu_filtered=[]
beta_var_filtered=[]
gamma_mu_filtered=[]
gamma_var_filtered=[]
for x in range(len_prognostic):
#learn phase
if x <= len_learn:
zs =x_obs[x]
pf.predict_ln_l(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma,gamma_process_nosie_sigma=gamma_init_gauss_sigma)
pf.update(z=zs)
# indexes = PF_C.residual_resample2(pf.weights)
# pf.resample_from_index(indexes)
pf.resample()
result=pf.estimate_2_para()
#prognostics phase
elif x > len_learn:
pf.prognosis_ln_l(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma,gamma_process_nosie_sigma=gamma_process_noise_sigma)
result=pf.estimate_2_para()
x_mu_filtered.append(result[0])
x_var_filtered.append(result[1])
beta_mu_filtered.append(result[2])
beta_var_filtered.append(result[3])
gamma_mu_filtered.append(result[4])
gamma_var_filtered.append(result[5])
x_particle.append(pf.particles[:,0])
beta_particle.append(pf.particles[:,1])
gamma_particle.append(pf.particles[:,2])
plt.figure()
plt.subplot(3,1,1)
# plot the learn phase data
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],x_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0,dashes=[10, 6, 1, 6, 1, 6])
#plot the threshold
plt_th.plot_threshold(sampled_data_FC=sampled_data)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],x_obs[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],x_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
# plt.ylim(3.1,3.5)
# plt.plot(t_real[0:iterations],x_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('voltage')
plt.title('ln_linear')
plt.legend(['observation','real data','filter'])
plt.subplot(3,1,2)
# # plot the learn phase data
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],beta_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_beta[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],beta_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
# plt.plot(t_real[0:iterations],beta_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('parameter - beta')
plt.xlim(0,1200)
plt.legend(['observation','real data','filter'])
plt.subplot(3,1,3)
# # plot the learn phase data
plt.plot(t_real[0:len_learn],para_gamma[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_gamma[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],gamma_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_gamma[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],gamma_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
# plt.plot(t_real[0:iterations],beta_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('parameter - gamma')
plt.xlim(0,1200)
plt.legend(['observation','real data','filter'])
elif sta_fun_kind=='Qua_ploy':
para_0=para[0][5]
para_1=para[0][6]
#para_0=0.001
# para_1=0.002
# gamma_distri_para=[-0.008,0.008]
para_beta=para[1][5,:]
para_gamma=para[1][6,:]
x_init_range=np.array([x_obs[0]-x_init_uniform_bound,x_obs[0]+x_init_uniform_bound])
beta_init_range=np.array([para_0-beta_init_uniform_bound,para_0+beta_init_uniform_bound])
gamma_init_range=np.array([para_1-gamma_init_uniform_bound,para_1+gamma_init_uniform_bound])
x_init_gauss=np.array([x_obs[0],x_init_gauss_sigma])
beta_init_gauss=np.array([para_0,beta_init_gauss_sigma])
gamma_init_gauss=np.array([para_1,gamma_init_gauss_sigma])
pf = PF_C.ParticleFilter(num_particles, x_range=x_init_range,
beta_range=beta_init_range,gamma_range=gamma_init_range,
measure_std_error=sensor_std_err)
pf.create_gaussian_particles(x_init_gauss,beta_init_gauss,gamma_init_gauss)
x_particle=[]
beta_particle=[]
gamma_particle=[]
x_mu_filtered=[]
x_var_filtered=[]
beta_mu_filtered=[]
beta_var_filtered=[]
gamma_mu_filtered=[]
gamma_var_filtered=[]
for x in range(len_prognostic):
#learn phase
if x <= len_learn:
zs =x_obs[x]
pf.predict_Qua_ploy(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma,gamma_process_nosie_sigma=gamma_process_noise_sigma)
pf.update(z=zs)
# indexes = PF_C.residual_resample2(pf.weights)
# pf.resample_from_index(indexes)
pf.resample()
result=pf.estimate_2_para()
#prognostics phase
elif x > len_learn:
pf.prognosis_Qua_ploy(k=x,t=t_real,x_process_noise_sigma=0.1,
beta_process_noise_sigma=beta_process_noise_sigma,gamma_process_nosie_sigma=gamma_process_noise_sigma)
result=pf.estimate_2_para()
x_mu_filtered.append(result[0])
x_var_filtered.append(result[1])
beta_mu_filtered.append(result[2])
beta_var_filtered.append(result[3])
gamma_mu_filtered.append(result[4])
gamma_var_filtered.append(result[5])
x_particle.append(pf.particles[:,0])
beta_particle.append(pf.particles[:,1])
gamma_particle.append(pf.particles[:,2])
x_particle=np.array(x_particle)
beta_particle=np.array(beta_particle)
gamma_particle=np.array(gamma_particle)
plt.figure()
plt.subplot(3,1,1)
# plot the learn phase data
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],x_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],x_obs[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],x_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0)
#plot the threshold
plt_th.plot_threshold(sampled_data_FC=sampled_data)
# plt.ylim(3.1,3.5)
# plt.plot(t_real[show_particle_index],x_particle[show_particle_index],'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('voltage')
#plt.ylim(3.0,3.35)
plt.title('Qua_ploy')
plt.legend(['observation','real data','filter'])
plt.subplot(3,1,2)
## # plot the learn phase data
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],beta_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
## plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_beta[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],beta_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
plt.plot(t_real[show_particle_index],beta_particle[show_particle_index],'k.',markersize=0.5)
plt.grid()
plt.xlim(0,1200)
plt.xlabel('real time')
plt.ylabel('parameter - beta')
#plt.legend(['observation','real data','filter'])
plt.subplot(3,1,3)
## # plot the learn phase data
plt.plot(t_real[0:len_learn],para_gamma[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_gamma[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],gamma_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
## plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_gamma[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],gamma_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
plt.plot(t_real[show_particle_index],gamma_particle[show_particle_index],'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('parameter - beta')
plt.xlim(0,1200)
#plt.legend(['observation','real data','filter'])
# plt.subplot(4,1,4)
# temp_data=[i-j for i,j in zip(beta_mu_filtered[0:len_prognostic],gamma_mu_filtered[0:len_prognostic])]
# plt.plot(t_real[0:len_prognostic],temp_data,'g',markersize=3.0,linewidth=3.0)
#
elif sta_fun_kind=='test':
para_0=para[0][1]
para_beta=para[1][1,:]
x_init_range=np.array([x_obs[0]-x_init_uniform_bound,x_obs[0]+x_init_uniform_bound])
beta_init_range=np.array([para_0-beta_init_uniform_bound,para_0+beta_init_uniform_bound])
x_init_gauss=np.array([x_obs[0],x_init_gauss_sigma])
beta_init_gauss=np.array([para_0,beta_init_gauss_sigma])
pf = PF_C.ParticleFilter(num_particles, x_range=x_init_range,
beta_range=beta_init_range,gamma_range=[-1,1],
measure_std_error=sensor_std_err)
pf.create_gaussian_particles(x_init_gauss,beta_init_gauss,[0,1])
x_particle=[]
beta_particle=[]
x_mu_filtered=[]
x_var_filtered=[]
beta_mu_filtered=[]
beta_var_filtered=[]
for x in range(len_prognostic):
#learn phase
if x <= len_learn:
zs =x_obs[x]
pf.predict_test(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
pf.update(z=zs)
# indexes = PF_C.residual_resample2(pf.weights)
# pf.resample_from_index(indexes)
pf.resample()
result=pf.estimate()
#prognostics phase
elif x > len_learn:
pf.prognosis_test(k=x,t=t_real,x_process_noise_sigma=x_process_noise_sigma,
beta_process_noise_sigma=beta_process_noise_sigma)
result=pf.estimate()
x_mu_filtered.append(result[0])
x_var_filtered.append(result[1])
beta_mu_filtered.append(result[2])
beta_var_filtered.append(result[3])
x_particle.append(pf.particles[:,0])
beta_particle.append(pf.particles[:,1])
plt.figure()
plt.subplot(2,1,1)
# plot the learn phase data
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],x_obs[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],x_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0,dashes=[10, 6, 1, 6, 1, 6])
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],x_obs[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],x_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
# plt.ylim(3.1,3.5)
# plt.plot(t_real[0:iterations],x_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time/hours')
plt.ylabel('voltage/v')
plt.title('ln')
plt.legend(['observation','real data','filter'])
plt.subplot(2,1,2)
# # plot the learn phase data
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'g-',markersize=8.0,linewidth=10.0,alpha=0.8)
plt.plot(t_real[0:len_learn],para_beta[0:len_learn],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[0:len_learn],beta_mu_filtered[0:len_learn],'r',markersize=3.0,linewidth=3.0)
# plot the predict phase data
plt.plot(t_real[len_learn-1:len_prognostic],para_beta[len_learn-1:len_prognostic],'b-',markersize=3.0,linewidth=3.0)
plt.plot(t_real[len_learn-1:len_prognostic],beta_mu_filtered[len_learn-1:len_prognostic],'r',markersize=3.0,linewidth=3.0,dashes=[8, 4, 2, 4, 2, 4])
# plt.plot(t_real[0:iterations],beta_particle,'k.',markersize=0.5)
plt.grid()
plt.xlabel('real time')
plt.ylabel('parameter - beta')
plt.legend(['observation','real data','filter'])
return np.array([[x_mu_filtered[0:len_learn],x_obs[0:len_learn]],[x_mu_filtered[len_learn-1:len_prognostic],x_obs[len_learn-1:len_prognostic]],[x_mu_filtered[0:len_prognostic],x_obs[0:len_prognostic]]])
X_temp1=list(X1[-1][:-1])+[sampled_data[len_train,0]]
X_temp1=np.array(X_temp1)
y_rbf_prog.append(svr_rbf.predict(X_temp1))
elif i < regressors_num:
X_temp=list(X1[-1][-(regressors_num-i)-1:-1])+y_rbf_prog+[sampled_data[i+len_train,0]]
X_temp=np.array(X_temp)
y_rbf_prog.append(svr_rbf.predict(X_temp))
elif i >= regressors_num:
X_temp=y_rbf_prog[-regressors_num:]+[sampled_data[i+len_train,0]]
X_temp=np.array(X_temp)
y_rbf_prog.append(svr_rbf.predict(X_temp))
########################################################################
# plot the results
y_rbf=list(y_rbf)
# y_reg_pred_final=y_rbf+y_rbf_prog
# print (len(y_reg_pred_final))
X_real=sampled_data_FC1_minus_FC2[:,0]
plt.plot(X_real[0:len_real],Y,c='r',label='real data')
# plt.plot(X[regressors_num:len_real],y_reg_pred_final,c='b')
plt.plot(X_real[regressors_num:len_train+1], y_rbf, c='g', label='RBF model')
plt.plot(X_real[len_train:len_real],y_rbf_prog,c='b',label='prognostic')
plt_th.plot_threshold(sampled_data_FC=sampled_data_FC1_minus_FC2)
plt.xlabel('data')
plt.ylabel('target')
plt.title('Support Vector Regression')
plt.legend()
plt.show()
