Skip to content

Instantly share code, notes, and snippets.

@muripoLife
Created April 24, 2020 11:29
Show Gist options
  • Save muripoLife/f3cbc8eda777da9e3f46df4c6932a0bc to your computer and use it in GitHub Desktop.
Save muripoLife/f3cbc8eda777da9e3f46df4c6932a0bc to your computer and use it in GitHub Desktop.
simple_kalman_filter
Display the source blob
Display the rendered blob
Raw
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
"_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
"collapsed": true
},
"source": [
"# カルマンフィルタ\n",
"https://github.com/ktysd/prob-tut/blob/master/Jupyter/Ch11.ipynb"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import matplotlib.gridspec as gridspec\n",
"from scipy.linalg import solve_discrete_are\n",
"from scipy.integrate import ode"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lib"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### display"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def plot_filtering_test( cls ):\n",
" fig = plt.figure(figsize=(5, 3.5))\n",
" gs = gridspec.GridSpec(2,2)\n",
" ax1 = fig.add_subplot(gs[0,:])\n",
" ax1.plot(cls.tt, cls.xx[:,1], '--', color='gray', linewidth=2, alpha=0.6, label='Exact')\n",
" ax1.plot(cls.tt, cls.yy, 'k-', linewidth=0.7, alpha=1.0, label='Noisy measurement')\n",
" ax1.set_xlim([cls.tt.min(),cls.tt.max()])\n",
" ax1.set_xlabel('$t$',fontsize=12)\n",
" ax1.set_ylabel('$y$',fontsize=12)\n",
" ax1.legend(bbox_to_anchor=(0.5, 1.0), loc='lower center')\n",
" ax2 = fig.add_subplot(gs[1,0])\n",
" ax2.plot(cls.xx[:,0], cls.xx[:,1], '--', color='gray', linewidth=2, alpha=0.6)\n",
" if cls.xxf is not None:\n",
" ax2.plot(cls.xxf[:,0], cls.xxf[:,1], 'k-', linewidth=0.7, alpha=1.0, label='KF filtered')\n",
" ax2.set_xlabel('$x_1$',fontsize=12)\n",
" ax2.set_ylabel('$x_2$',fontsize=12)\n",
" ax2.legend(bbox_to_anchor=(0.5, 1.0), loc='lower center')\n",
" if cls.xxni is not None:\n",
" ax3 = fig.add_subplot(gs[1,1])\n",
" ax3.plot(cls.xx[:,0], cls.xx[:,1], '--', color='gray', linewidth=2, alpha=0.6)\n",
" ax3.plot(cls.xxni[:,0], cls.xxni[:,1], 'k-', linewidth=0.7, alpha=1.0, label='NI estimated')\n",
" ax3.set_xlabel('$x_1$',fontsize=12)\n",
" ax3.set_ylabel('$x_2$',fontsize=12)\n",
" ax3.legend()\n",
" ax3.legend(bbox_to_anchor=(0.5, 1.0), loc='lower center')\n",
"\n",
" plt.tight_layout()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### SDE"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"class class_SDE:\n",
" # dx/dt = state_eqn(t, x)\n",
" # y = output_eqn(x) + v\n",
"\n",
" def __init__(self, xdim, ydim, Q, R):\n",
"\n",
" ### システムのサイズ\n",
" self.xdim = xdim #状態の次元\n",
" self.ydim = ydim #観測の次元\n",
"\n",
" ### 雑音\n",
" self.Q = np.array(Q) #システム雑音の共分散\n",
" self.wdim = self.Q.shape[0] #システム雑音の次元\n",
" self.w = np.zeros(self.wdim) #システム雑音ベクトル\n",
" self.wav = np.zeros(self.wdim) #システム雑音の平均\n",
" self.R = np.array(R) #観測雑音の共分散\n",
" self.vdim = self.R.shape[0] #観測雑音の次元\n",
" self.v = np.zeros(self.vdim) #観測雑音ベクトル\n",
" self.vav = np.zeros(self.vdim) #観測雑音の平均\n",
"\n",
" def setup(s, x0, dt, t0=0.0, solver_type='dopri5'):\n",
" s.x0 = np.array(x0) #初期状態ベクトル\n",
" s.dx = np.zeros_like(s.x0) #状態ベクトルの時間微分\n",
" s.dt = dt #積分ステップ \n",
" s.t0 = t0 #初期時刻\n",
" ### ソルバの設定\n",
" s.solver = ode(s.StateEqn).set_integrator(solver_type)\n",
" s.solver.set_initial_value( s.x0, s.t0 )\n",
" ### クラス変数をソルバと同期\n",
" s.t = s.solver.t #クラス変数(t,x)はsolver内の(x,y)に対応\n",
" s.x = s.solver.y #状態ベクトルの初期値\n",
" s.y = s.get_output() #観測ベクトルの初期値\n",
"\n",
" def StateEqn(s, t, x): \n",
" # dx/dt = StateEqn(t, x)\n",
" # 関数内でシステム雑音 s.w, 一時保持用の s.dx が使える.\n",
" ### dummy ###\n",
" s.dx = x\n",
" return s.dx\n",
"\n",
" def OutputEqn(s, x): #dx/dt = StateEqn(t, x)\n",
" # y = output_func(x) + v\n",
" # 観測雑音 v はget_output()で自動的に加算される \n",
" ### dummy ###\n",
" y = x\n",
" return y\n",
"\n",
" def get_output(s): \n",
" ### 雑音の更新\n",
" s.update_v()\n",
" return s.OutputEqn(s.x) + s.v\n",
"\n",
" def update_w(s):\n",
" if s.wdim == 1:\n",
" s.w = np.sqrt(s.Q[0]) * np.random.randn() #正規乱数\n",
" else:\n",
" s.w = np.random.multivariate_normal(s.wav, s.Q)\n",
" \n",
" def update_v(s):\n",
" if s.vdim == 1:\n",
" s.v = np.sqrt(s.R[0]) * np.random.randn() #正規乱数\n",
" else:\n",
" s.v = np.random.multivariate_normal(s.vav, s.R)\n",
"\n",
" def propagator(s, x0, t0): \n",
" ### 雑音の更新\n",
" s.update_w()\n",
"\n",
" # 算法12.1にあるDの補正と同じことを,wの補正でしている.\n",
" # 砂原「確率システム理論」ISBN:4-88552-028-2, 89頁など\n",
" inv_sqrt_dt = 1.0/np.sqrt(s.dt)\n",
" s.w *= inv_sqrt_dt\n",
"\n",
" s.solver.set_initial_value( x0, t0 )\n",
" s.solver.integrate(s.solver.t + s.dt)\n",
"\n",
" return (s.solver.y, s.solver.t) #本クラスの(t,x)はsolverの(t,y)\n",
" \n",
" def solve(s):\n",
" s.x, s.t = s.propagator(s.x, s.t)\n",
"\n",
" def set_input(s, u):\n",
" s.u = u\n",
"\n",
" def get_sample_path(s, tn):\n",
" tt = np.zeros(tn+1) #時刻の列\n",
" xx = np.zeros((tn+1, s.xdim)) #状態ベクトルの時系列\n",
" yy = np.zeros((tn+1, s.ydim)) #観測ベクトルの時系列\n",
"\n",
" for i in range(tn+1):\n",
" tt[i] = s.t\n",
" xx[i,:] = s.x\n",
" yy[i] = s.get_output()\n",
" s.solve()\n",
"\n",
" return tt, xx, yy"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"class class_LinearSDE(class_SDE): #SDEの子クラス\n",
"\n",
" def __init__(self, A, D, C, Q, R, x0, dt, t0=0.0, B=None):\n",
"\n",
" ### システム行列\n",
" self.A = np.array(A) #状態行列\n",
" self.D = np.array(D) #駆動行列\n",
" self.C = np.array(C) #観測行列\n",
" # システムのサイズ\n",
" xdim = A.shape[1] #状態の次元=Aの列数\n",
" ydim = C.shape[0] #観測の次元=Cの行数\n",
" wdim = D.shape[1] #システム雑音の次元=Dの列数\n",
"\n",
" super().__init__(xdim, ydim, Q, R)\n",
"\n",
" ### 制御入力\n",
" if B is not None:\n",
" self.B = np.array(B)\n",
" self.udim = self.B.shape[1] #制御入力の次元\n",
" self.u = np.zeros(self.udim)\n",
" else:\n",
" self.udim = 0\n",
" \n",
" ### 初期設定\n",
" self.setup(x0, dt, t0)\n",
"\n",
" ### 確率微分方程式(SDE: stochastic differential equation)\n",
" def StateEqn(s, t, x):\n",
" Dww = np.ravel(s.D.dot(s.w)) #odeのベクトルは1次元配列\n",
"\n",
" dx0 = s.A.dot(x) + Dww\n",
" \n",
" if s.udim==0:\n",
" dx = dx0\n",
" else:\n",
" Bu = np.ravel(s.B.dot(s.u)) #odeのベクトルは1次元配列\n",
" dx = dx0 + Bu\n",
"\n",
" return dx\n",
"\n",
" def OutputEqn(s, x):\n",
" return s.C.dot(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Kalman Filter"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"class class_ssKF: # Steady-state Kalman filter\n",
" \n",
" def __init__(s, F, G, H, Q, R, x0, cov0=None):\n",
" \n",
" ### システム行列\n",
" s.F = np.array(F) #状態推移行列\n",
" s.G = np.array(G) #駆動行列\n",
" s.H = np.array(H) #観測行列\n",
" # 雑音\n",
" s.Q = np.array(Q) #システム雑音の共分散行列\n",
" s.R = np.array(R) #観測雑音の共分散行列\n",
" \n",
" s.xdim = F.shape[1] #状態ベクトルの次元=状態推移行列の列数\n",
" s.ydim = H.shape[0] #観測行列の行数\n",
" \n",
" ### KBFの内部状態\n",
" s.xf = np.array(x0) #濾波推定値\n",
" s.xp = np.array(x0) #予測推定値\n",
" s.cov0 = cov0 #共分散行列\n",
" s.K = None #カルマンゲイン\n",
"\n",
" ### 定常カルマンフィルタの導出\n",
" RicA = s.F.T\n",
" RicB = s.H.T\n",
" RicQ = s.G.dot(s.Q).dot(s.G.T)\n",
" RicR = s.R\n",
" #リカッチ方程式の解\n",
" s.cov = solve_discrete_are(RicA, RicB, RicQ, RicR) \n",
" #定常カルマンゲイン\n",
" HSH_R = s.H.dot(s.cov).dot(s.H.T)+s.R\n",
" if HSH_R.ndim > 1:\n",
" pinv = np.linalg.pinv(HSH_R)\n",
" else:\n",
" pinv = 1.0/HSH_R\n",
" s.K = s.cov.dot(s.H.T).dot(pinv) \n",
" print('Steady-state Kalman gain =\\n', s.K)\n",
"\n",
" def recursion(s, yt, xp):\n",
"\n",
" # Filtering: xf ... x_t/t\n",
" xf = xp + s.K.dot( yt - s.H.dot(xp) ) \n",
"\n",
" # Prediction: xp ... x_t+1/t\n",
" xp = s.F.dot(xf)\n",
"\n",
" return (xf, xp)\n",
" \n",
" ### フィルタリング\n",
" def filtering(s, y):\n",
"\n",
" s.xf, s.xp = s.recursion(y, s.xp)\n",
"\n",
" ### 安定判別\n",
" def stability(s):\n",
"\n",
" stability_matrix = s.F - np.dot(s.K, s.H)\n",
" val,vec = np.linalg.eig( stability_matrix )\n",
" absval = np.abs(val)\n",
" if absval.max() < 1:\n",
" print( 'This filter is stable' )\n",
" else:\n",
" print( 'This filter is unstable' )\n",
" print( '> Eigenvalues:' )\n",
" for v in val:\n",
" print( '> ' + str(v) )\n",
" print( '> Their absolute values:' )\n",
" for av in absval:\n",
" print( '> ' + str(av) )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 数値例"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"class Vib1DOF: # 連続時間1自由度振動系,フィルタは離散時間\n",
" \n",
" def __init__(self, c=0.3, k=1.0, Δt=0.1, Qval=1e-8, Rval=0.1 ):\n",
" ### システムの定義\n",
" # 状態行列\n",
" self.A = np.array([[0,1],[-k,-c]])\n",
" # 駆動行列\n",
" self.D = np.array([[0],[1]]) #縦ベクトル \n",
" # 観測行列:1行2列と仮定\n",
" self.C = np.array([[0,1]])\n",
" # ノイズの条件\n",
" self.Q = np.array([[Qval]]) #スカラは1x1行列として与える\n",
" self.R = np.array([[Rval]]) #同上\n",
" ### 出力データ\n",
" self.tt = None # 時刻の列\n",
" self.xx = None # 状態量の時系列\n",
" self.yy = None # 観測量の時系列\n",
" self.xxf = None # 濾波推定値の時系列\n",
" self.xxni = None # 数値積分推定値の時系列\n",
" ### その他\n",
" self.Δt = Δt # 数値積分の時間ステップ\n",
" \n",
" ### 標本路の取得\n",
" def get_sample_path(s, x0=[1,0], tn=200):\n",
" # 初期値とデータ長\n",
" s.x0 = np.array(x0)\n",
" s.tn = tn\n",
" sde = class_LinearSDE(s.A, s.D, s.C, s.Q, s.R, s.x0, s.Δt)\n",
" s.tt, s.xx, s.yy = sde.get_sample_path(tn)\n",
" \n",
" ### 濾波推定(離散時間定常カルマンフィルタ)\n",
" def do_filtering(s):\n",
" I = np.eye(len(s.x0))\n",
" F = I + s.Δt*s.A\n",
" G = np.sqrt(s.Δt)*s.D\n",
" H = s.C\n",
" x0 = s.x0\n",
" cov0 = None\n",
" kf = class_ssKF(F, G, H, s.Q, s.R, x0)\n",
" s.xxf = np.zeros((s.tn+1,2))\n",
" for t, yt in enumerate(s.yy):\n",
" s.xxf[t,:] = kf.xf\n",
" kf.filtering(yt)\n",
" # フィルタの安定性の確認 \n",
" kf.stability() \n",
"\n",
" ### 数値積分による推定\n",
" def do_NI_estimation(self):\n",
" self.xxni = np.zeros((self.tn+1,2))\n",
" xni = self.x0[0]\n",
" for t, yt in enumerate(self.yy):\n",
" self.xxni[t,0] = xni #観測された速度の数値積分値\n",
" self.xxni[t,1] = yt #観測された速度そのもの\n",
" xni += yt*self.Δt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 数値積分推定との比較"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Steady-state Kalman gain =\n",
" [[-0.00565565]\n",
" [ 0.1167344 ]]\n",
"This filter is stable\n",
"> Eigenvalues:\n",
"> (0.9266327986216227+0.07199179733191377j)\n",
"> (0.9266327986216227-0.07199179733191377j)\n",
"> Their absolute values:\n",
"> 0.929425178464851\n",
"> 0.929425178464851\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 360x252 with 3 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# システム雑音 + 観測雑音\n",
"vib1 = Vib1DOF(Qval=0.01, Rval=0.05)\n",
"vib1.get_sample_path(tn=200)\n",
"vib1.do_filtering()\n",
"vib1.do_NI_estimation()\n",
"plot_filtering_test(vib1)\n",
"# plt.savefig('figs/Ch11-Q1R1.eps', bbox_inches='tight')"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Steady-state Kalman gain =\n",
" [[-2.14627777e-17]\n",
" [-4.42531499e-18]]\n",
"This filter is stable\n",
"> Eigenvalues:\n",
"> (0.9850000000000002+0.09886859966642597j)\n",
"> (0.9850000000000002-0.09886859966642597j)\n",
"> Their absolute values:\n",
"> 0.9899494936611668\n",
"> 0.9899494936611668\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 360x252 with 3 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# システム雑音なし + 観測雑音\n",
"vib1 = Vib1DOF(Qval=0, Rval=0.05)\n",
"vib1.get_sample_path(tn=200)\n",
"vib1.do_filtering()\n",
"vib1.do_NI_estimation()\n",
"plot_filtering_test(vib1)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Steady-state Kalman gain =\n",
" [[0.]\n",
" [1.]]\n",
"This filter is stable\n",
"> Eigenvalues:\n",
"> 0.9901979809935904\n",
"> -0.0201979809935903\n",
"> Their absolute values:\n",
"> 0.9901979809935904\n",
"> 0.0201979809935903\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 360x252 with 3 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# システム雑音 + 観測雑音なし\n",
"vib1 = Vib1DOF(Qval=0.01, Rval=0)\n",
"vib1.get_sample_path(tn=200)\n",
"vib1.do_filtering()\n",
"vib1.do_NI_estimation()\n",
"plot_filtering_test(vib1)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.6"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment