カルマンフィルタメモ


```py
import numpy as np

class KalmanFilter:
    def __init__(self, A, B, H, Q, R, x0, P0):
        self.A = A  # 状態遷移行列
        self.B = B  # 制御行列
        self.H = H  # 観測行列
        self.Q = Q  # システム雑音の共分散
        self.R = R  # 観測雑音の共分散
        self.x = x0  # 初期状態推定値
        self.P = P0  # 初期状態推定の共分散

    def predict(self, u):
        # 状態予測
        self.x = self.A @ self.x + self.B @ u
        # 共分散予測
        self.P = self.A @ self.P @ self.A.T + self.Q

    def update(self, z):
        # カルマンゲインの計算
        K = self.P @ self.H.T @ np.linalg.inv(self.H @ self.P @ self.H.T + self.R)
        # 状態推定値の更新
        self.x = self.x + K @ (z - self.H @ self.x)
        # 共分散の更新
        self.P = self.P - K @ self.H @ self.P

    def get_state(self):
        return self.x

# パラメータ設定
A = np.array([[1, 1], [0, 1]])  # 状態遷移行列
B = np.array([[0.5], [1]])      # 制御行列
H = np.array([[1, 0]])          # 観測行列
Q = np.array([[0.01, 0], [0, 0.01]])  # システム雑音の共分散
R = np.array([[1]])             # 観測雑音の共分散
x0 = np.array([[0], [1]])       # 初期状態推定値
P0 = np.eye(2)                  # 初期状態推定の共分散

# カルマンフィルターの初期化
kf = KalmanFilter(A, B, H, Q, R, x0, P0)

# データ生成（例としてシンプルなシステム）
num_steps = 50
true_state = np.zeros((2, num_steps))
observations = np.zeros((1, num_steps))

# 初期状態
true_state[:, 0] = x0.flatten()

# システム雑音と観測雑音の標準偏差
system_noise_std = np.sqrt(Q.diagonal())
observation_noise_std = np.sqrt(R.diagonal())

# 状態と観測データの生成
for k in range(1, num_steps):
    true_state[:, k] = A @ true_state[:, k-1] + B @ np.random.randn(1) * system_noise_std
    observations[:, k] = H @ true_state[:, k] + np.random.randn(1) * observation_noise_std

# フィルタリング
filtered_state = np.zeros((2, num_steps))
filtered_state[:, 0] = x0.flatten()

for k in range(1, num_steps):
    kf.predict(np.zeros((1, 1)))  # 制御入力uがゼロの場合
    kf.update(observations[:, k])
    filtered_state[:, k] = kf.get_state().flatten()

# 結果のプロット
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 8))
plt.plot(true_state[0, :], label='True Position')
plt.plot(observations.flatten(), label='Observations', linestyle='dotted')
plt.plot(filtered_state[0, :], label='Filtered Position')
plt.legend()
plt.xlabel('Time Step')
plt.ylabel('Position')
plt.title('Kalman Filter - Position Estimation')
plt.show()



```



```py

import numpy as np
import matplotlib.pyplot as plt
from scipy.ndimage import gaussian_filter
from scipy.stats import multivariate_normal

# 1. Kalman Filter
true_value = 10
observations = true_value + np.random.normal(0, 1, 100)

x = 0.0  # Initial state estimate
P = 1.0  # Initial estimate error covariance
Q = 1e-5  # Process noise covariance
R = 1.0  # Measurement noise covariance

filtered_values = []

for z in observations:
    x = x  # State prediction
    P = P + Q  # Covariance prediction
    K = P / (P + R)  # Kalman gain
    x = x + K * (z - x)  # State update
    P = (1 - K) * P  # Covariance update
    filtered_values.append(x)

plt.figure(figsize=(10, 6))
plt.plot(observations, label='Observations', linestyle='dotted')
plt.plot(filtered_values, label='Kalman Filter Estimates', linestyle='solid')
plt.axhline(true_value, color='red', linestyle='dashed', label='True Value')
plt.legend()
plt.title('Kalman Filter')
plt.show()

# 2. Gaussian Filter
data = np.sin(np.linspace(0, 20, 100)) + np.random.normal(0, 0.5, 100)
smoothed_data = gaussian_filter(data, sigma=2)

plt.figure(figsize=(10, 6))
plt.plot(data, label='Original Data', linestyle='dotted')
plt.plot(smoothed_data, label='Gaussian Filtered Data', linestyle='solid')
plt.legend()
plt.title('Gaussian Filter')
plt.show()

# 3. Multivariate Gaussian Distribution, Mean, Covariance Matrix
mean = [0, 0]
cov = [[1, 0.5], [0.5, 1]]
data = np.random.multivariate_normal(mean, cov, 500)

plt.figure(figsize=(10, 6))
plt.scatter(data[:, 0], data[:, 1], s=10)
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('Multivariate Gaussian Distribution')
plt.grid(True)
plt.axis('equal')
plt.show()

# 4. Bayesian Filter
state_space = np.linspace(-10, 10, 100)
observations = np.linspace(-10, 10, 50)
prior = np.exp(-0.5 * (state_space / 2)**2)
prior /= prior.sum()
observation = 2.0
likelihood = np.exp(-0.5 * ((state_space - observation) / 1.0)**2)
likelihood /= likelihood.sum()
posterior = likelihood * prior
posterior /= posterior.sum()

plt.figure(figsize=(10, 6))
plt.plot(state_space, prior, label='Prior')
plt.plot(state_space, likelihood, label='Likelihood')
plt.plot(state_space, posterior, label='Posterior')
plt.legend()
plt.title('Bayesian Filter')
plt.show()


```



```py


import numpy as np
import matplotlib.pyplot as plt

# シミュレーションのパラメータ
dt = 0.1  # 時間間隔
num_steps = 100  # ステップ数
true_initial_position = 0  # 真の初期位置
true_initial_velocity = 1  # 真の初期速度

# プロセスノイズと観測ノイズ
process_noise_std = 0.1
measurement_noise_std = 0.5

# 状態遷移行列と観測行列
A = np.array([[1, dt], [0, 1]])  # 状態遷移行列
B = np.array([[0.5 * dt**2], [dt]])  # 制御入力行列
H = np.array([[1, 0]])  # 観測行列

# プロセスノイズ共分散行列と観測ノイズ共分散行列
Q = np.array([[process_noise_std**2, 0], [0, process_noise_std**2]])
R = np.array([[measurement_noise_std**2]])

# 初期状態
x_true = np.array([[true_initial_position], [true_initial_velocity]])
x_est = np.array([[0], [0]])  # 初期推定位置と速度
P = np.eye(2)  # 初期推定誤差共分散行列

# 状態と観測の履歴
true_positions = []
measurements = []
estimated_positions = []

# 制御入力（加速度）
u = np.array([[0]])

# カルマンフィルタのループ
for _ in range(num_steps):
    # 真の状態を更新
    x_true = A @ x_true + B @ u + np.random.multivariate_normal([0, 0], Q).reshape(-1, 1)
    true_positions.append(x_true[0, 0])
    
    # ノイズを加えた観測
    z = H @ x_true + np.random.normal(0, measurement_noise_std)
    measurements.append(z[0, 0])
    
    # カルマンフィルタの予測ステップ
    x_pred = A @ x_est + B @ u
    P_pred = A @ P @ A.T + Q
    
    # カルマンフィルタの更新ステップ
    K = P_pred @ H.T @ np.linalg.inv(H @ P_pred @ H.T + R)  # カルマンゲイン
    x_est = x_pred + K @ (z - H @ x_pred)  # 状態推定更新
    P = (np.eye(2) - K @ H) @ P_pred  # 誤差共分散更新
    
    estimated_positions.append(x_est[0, 0])

# プロット
plt.figure(figsize=(10, 6))
plt.plot(true_positions, label='True Position', linestyle='dashed')
plt.plot(measurements, label='Measurements', linestyle='dotted')
plt.plot(estimated_positions, label='Kalman Filter Estimate', linestyle='solid')
plt.xlabel('Time Step')
plt.ylabel('Position')
plt.legend()
plt.title('Kalman Filter for Robot Control and State Transition')
plt.show()

```



```py

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import lfilter
from statsmodels.tsa.arima_process import ArmaProcess

# ARMAモデルのパラメータ
ar_params = np.array([1, -0.5, 0.25])  # AR係数
ma_params = np.array([1, 0.4, -0.3])   # MA係数

# ARMAプロセスのインスタンスを作成
arma_process = ArmaProcess(ar=ar_params, ma=ma_params)

# データを生成
num_samples = 100
np.random.seed(42)
true_values = arma_process.generate_sample(nsample=num_samples)

# ノイズを加えた観測値
observation_noise_std = 0.5
observations = true_values + np.random.normal(0, observation_noise_std, num_samples)

# カルマンフィルタの設定
n = len(true_values)
A = np.eye(2)
C = np.array([[1, 0]])
Q = np.eye(2) * 0.01
R = np.array([[observation_noise_std ** 2]])

# 初期値
x_est = np.zeros((2, 1))
P = np.eye(2)

# フィルタリング結果を格納するリスト
filtered_values = []

# カルマンフィルタのループ
for z in observations:
    # 予測ステップ
    x_pred = A @ x_est
    P_pred = A @ P @ A.T + Q
    
    # 更新ステップ
    K = P_pred @ C.T @ np.linalg.inv(C @ P_pred @ C.T + R)
    x_est = x_pred + K @ (z - C @ x_pred)
    P = (np.eye(2) - K @ C) @ P_pred
    
    filtered_values.append(x_est[0, 0])

# プロット
plt.figure(figsize=(10, 6))
plt.plot(true_values, label='True Values', linestyle='dashed')
plt.plot(observations, label='Observations', linestyle='dotted')
plt.plot(filtered_values, label='Kalman Filter Estimate', linestyle='solid')
plt.xlabel('Time Step')
plt.ylabel('Value')
plt.legend()
plt.title('Kalman Filter with ARMA Model for Economic Data')
plt.show()


```






```
import numpy as np
import matplotlib.pyplot as plt

# システムパラメータ
dt = 1.0  # 時間ステップ
A = np.array([[1, dt], [0, 1]])  # 状態遷移行列
H = np.array([[1, 0]])  # 観測行列
Q = np.array([[1, 0], [0, 3]])  # プロセスノイズ共分散行列
R = np.array([[10]])  # 観測ノイズ共分散行列

# 初期状態
x = np.array([[0], [1]])  # 初期状態 [位置, 速度]
P = np.eye(2)  # 初期推定誤差共分散行列

# 真の状態と観測値
true_positions = []
observations = []

# カルマンフィルタの推定結果
estimated_positions = []

for i in range(50):
    # 真の状態
    x_true = A @ x + np.random.multivariate_normal([0, 0], Q).reshape(-1, 1)
    true_positions.append(x_true[0, 0])
    
    # 観測値
    z = H @ x_true + np.random.normal(0, R)
    observations.append(z[0, 0])
    
    # 予測ステップ
    x_pred = A @ x
    P_pred = A @ P @ A.T + Q
    
    # カルマンゲインの計算
    K = P_pred @ H.T @ np.linalg.inv(H @ P_pred @ H.T + R)
    
    # 更新ステップ
    x = x_pred + K @ (z - H @ x_pred)
    P = (np.eye(2) - K @ H) @ P_pred
    
    # 推定結果の保存
    estimated_positions.append(x[0, 0])

# プロット
plt.figure(figsize=(10, 6))
plt.plot(true_positions, label='True Position', linestyle='dashed')
plt.plot(observations, label='Observations', linestyle='dotted')
plt.plot(estimated_positions, label='Kalman Filter Estimate', linestyle='solid')
plt.xlabel('Time Step')
plt.ylabel('Position')
plt.legend()
plt.title('1D Kalman Filter')
plt.show()
```



```
import numpy as np
import matplotlib.pyplot as plt

# シミュレーションパラメータ
num_samples = 100
observation_noise_std = 0.5

# 移動平均モデル (MA(2))
ma_params = np.array([0.6, -0.3])
np.random.seed(42)
white_noise = np.random.normal(0, 1, num_samples + len(ma_params))
true_values = np.convolve(white_noise, ma_params, mode='valid')

# ノイズを加えた観測値
observations = true_values + np.random.normal(0, observation_noise_std, len(true_values))

# ベイズ推定のパラメータ
state_space = np.linspace(-3, 3, 100)
prior = np.exp(-0.5 * (state_space / 1.0)**2)
prior /= prior.sum()

# 初期設定
x_est = 0  # 初期推定値
P = 1.0  # 初期推定誤差共分散
Q = 0.01  # プロセスノイズ共分散
R = observation_noise_std ** 2  # 観測ノイズ共分散

# カルマンフィルタの結果を格納するリスト
filtered_values = []
posteriors = []

# カルマンフィルタのループ
for z in observations:
    # ベイズ推定：尤度計算
    likelihood = np.exp(-0.5 * ((state_space - z) / observation_noise_std)**2)
    likelihood /= likelihood.sum()
    
    # 事後分布の計算
    posterior = likelihood * prior
    posterior /= posterior.sum()
    
    # カルマンフィルタの予測ステップ
    x_pred = x_est
    P_pred = P + Q
    
    # カルマンゲインの計算
    K = P_pred / (P_pred + R)
    
    # 更新ステップ
    x_est = x_pred + K * (z - x_pred)
    P = (1 - K) * P_pred
    
    # 事前分布を更新
    prior = posterior
    
    # 結果の保存
    filtered_values.append(x_est)
    posteriors.append(posterior)

# プロット
plt.figure(figsize=(14, 6))

# 真の値、観測値、カルマンフィルタの推定値
plt.subplot(1, 2, 1)
plt.plot(true_values, label='True Values', linestyle='dashed')
plt.plot(observations, label='Observations', linestyle='dotted')
plt.plot(filtered_values, label='Kalman Filter Estimate', linestyle='solid')
plt.xlabel('Time Step')
plt.ylabel('Value')
plt.legend()
plt.title('Kalman Filter with MA Model and Bayesian Estimation')

# 事後分布のプロット
plt.subplot(1, 2, 2)
plt.imshow(np.array(posteriors).T, aspect='auto', origin='lower', extent=[0, len(observations), state_space[0], state_space[-1]])
plt.colorbar(label='Probability')
plt.xlabel('Time Step')
plt.ylabel('State Space')
plt.title('Posterior Distribution Over Time')

plt.tight_layout()
plt.show()



```




```
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import butter, filtfilt

# シミュレーションパラメータ
num_samples = 100
observation_noise_std = 0.5

# データ生成 (正弦波 + ノイズ)
np.random.seed(42)
time = np.linspace(0, 1, num_samples)
true_signal = np.sin(2 * np.pi * 5 * time)  # 5Hzの正弦波
observations = true_signal + np.random.normal(0, observation_noise_std, num_samples)

# 低パスフィルタの設計
def low_pass_filter(data, cutoff, fs, order=5):
    nyquist = 0.5 * fs
    normal_cutoff = cutoff / nyquist
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    filtered_data = filtfilt(b, a, data)
    return filtered_data

# 低パスフィルタでノイズ除去
fs = 1 / (time[1] - time[0])  # サンプリング周波数
cutoff = 10  # カットオフ周波数
filtered_signal = low_pass_filter(observations, cutoff, fs)

# カルマンフィルタの設定
A = np.eye(2)
H = np.array([[1, 0]])
Q = np.eye(2) * 0.01
R = np.array([[observation_noise_std ** 2]])

# 初期設定
x_est = np.zeros((2, 1))
P = np.eye(2)

# カルマンフィルタの結果を格納するリスト
filtered_values = []

# カルマンフィルタのループ
for z in filtered_signal:
    # 予測ステップ
    x_pred = A @ x_est
    P_pred = A @ P @ A.T + Q
    
    # 更新ステップ
    K = P_pred @ H.T @ np.linalg.inv(H @ P_pred @ H.T + R)
    x_est = x_pred + K @ (z - H @ x_pred)
    P = (np.eye(2) - K @ H) @ P_pred
    
    # 結果の保存
    filtered_values.append(x_est[0, 0])

# プロット
plt.figure(figsize=(14, 6))

# 真の信号、観測値、低パスフィルタによる信号、カルマンフィルタの推定値
plt.subplot(1, 1, 1)
plt.plot(time, true_signal, label='True Signal', linestyle='dashed')
plt.plot(time, observations, label='Noisy Observations', linestyle='dotted')
plt.plot(time, filtered_signal, label='Low-pass Filtered Signal', linestyle='dashdot')
plt.plot(time, filtered_values, label='Kalman Filter Estimate', linestyle='solid')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.title('Low-pass Filtering and Kalman Filtering')
plt.show()


```



```
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.arima_process import ArmaProcess
from statsmodels.tsa.arima.model import ARIMA

# パラメータ設定
np.random.seed(0)

# ARモデル
ar_params = np.array([0.75, -0.25])
ar = np.r_[1, -ar_params]  # AR部分
ma = np.array([1])         # MA部分
AR_object = ArmaProcess(ar, ma)
AR_sample = AR_object.generate_sample(nsample=1000)

# MAモデル
ma_params = np.array([0.65, 0.35])
ar = np.array([1])
ma = np.r_[1, ma_params]  # MA部分
MA_object = ArmaProcess(ar, ma)
MA_sample = MA_object.generate_sample(nsample=1000)

# ARMAモデル
ar_params = np.array([0.75, -0.25])
ma_params = np.array([0.65, 0.35])
ar = np.r_[1, -ar_params]  # AR部分
ma = np.r_[1, ma_params]   # MA部分
ARMA_object = ArmaProcess(ar, ma)
ARMA_sample = ARMA_object.generate_sample(nsample=1000)

# ARIMAモデル
d = 1  # 差分の次数
arima_model = ARIMA(ARMA_sample, order=(2, d, 2))
ARIMA_result = arima_model.fit()
ARIMA_sample = ARIMA_result.predict(start=d, end=1000)

# プロット
plt.figure(figsize=(14, 10))

plt.subplot(4, 1, 1)
plt.plot(AR_sample, color='blue')
plt.title('AR Model')

plt.subplot(4, 1, 2)
plt.plot(MA_sample, color='green')
plt.title('MA Model')

plt.subplot(4, 1, 3)
plt.plot(ARMA_sample, color='red')
plt.title('ARMA Model')

plt.subplot(4, 1, 4)
plt.plot(ARIMA_sample, color='purple')
plt.title('ARIMA Model')

plt.tight_layout()
plt.show()


```



```
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pykalman import KalmanFilter

# Generate sample time series data with a seasonal component
np.random.seed(0)
time = np.arange(100)
seasonal_component = 10 + np.sin(2 * np.pi * time / 10)
trend_component = 0.1 * time
noise = np.random.normal(0, 1, size=100)
data = seasonal_component + trend_component + noise

# Apply Kalman Filter to the data
initial_state_mean = [data[0], 0]
transition_matrix = [[1, 1], [0, 1]]
observation_matrix = [[1, 0]]

kf = KalmanFilter(
    initial_state_mean=initial_state_mean,
    transition_matrices=transition_matrix,
    observation_matrices=observation_matrix
)

state_means, _ = kf.filter(data)
trend_estimate = state_means[:, 0]

# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(time, data, label='Observed Data', linestyle='--', marker='o')
plt.plot(time, trend_estimate, label='Estimated Trend', color='red')
plt.plot(time, data - trend_estimate, label='Seasonal Component', color='green')
plt.legend()
plt.title('Kalman Filter Seasonal Adjustment')
plt.xlabel('Time')
plt.ylabel('Value')
plt.show()


```
```
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVR

# ロトカ・ヴォルテラ方程式
def lotka_volterra(X, t, alpha, beta, delta, gamma):
    prey, predator = X
    dprey_dt = alpha * prey - beta * prey * predator
    dpredator_dt = delta * prey * predator - gamma * predator
    return [dprey_dt, dpredator_dt]

# パラメータ
alpha = 1.0   # 被食者の出生率
beta = 0.1    # 捕食による被食者の死亡率
delta = 0.075 # 捕食された被食者1匹当たりの捕食者の出生率
gamma = 1.5   # 捕食者の死亡率

# 初期の個体数
X0 = [10, 5]

# 時間の範囲
t = np.linspace(0, 50, 500)

# 微分方程式を解く
X = odeint(lotka_volterra, X0, t, args=(alpha, beta, delta, gamma))

# ノイズを追加した観測値
noisy_X = X + np.random.normal(0, 2, X.shape)

# データを学習用とテスト用に分割
split_ratio = 0.8
split_index = int(len(t) * split_ratio)
t_train, t_test = t[:split_index], t[split_index:]
noisy_X_train, noisy_X_test = noisy_X[:split_index], noisy_X[split_index:]

# 線形回帰モデル
linear_model = LinearRegression()
linear_model.fit(t_train.reshape(-1, 1), noisy_X_train)
linear_pred = linear_model.predict(t_test.reshape(-1, 1))

# SVMモデル
svm_model = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
svm_model.fit(t_train.reshape(-1, 1), noisy_X_train[:, 0])  # Prey population
svm_pred_prey = svm_model.predict(t_test.reshape(-1, 1))

svm_model.fit(t_train.reshape(-1, 1), noisy_X_train[:, 1])  # Predator population
svm_pred_predator = svm_model.predict(t_test.reshape(-1, 1))

# 結果をプロット
fig, axs = plt.subplots(3, 1, figsize=(12, 18), sharex=True)

# 真の個体数
axs[0].plot(t, X[:, 0], 'g-', label='True Prey Population')
axs[0].plot(t, X[:, 1], 'b-', label='True Predator Population')
axs[0].set_ylabel('Population')
axs[0].legend()
axs[0].set_title('True Population')

# ノイズのある観測値
axs[1].plot(t, noisy_X[:, 0], color='green', alpha=0.5, label='Noisy Prey Observations')
axs[1].plot(t, noisy_X[:, 1], color='blue', alpha=0.5, label='Noisy Predator Observations')
axs[1].set_ylabel('Population')
axs[1].legend()
axs[1].set_title('Noisy Observations')

# 推定結果（線形回帰とSVM）
axs[2].plot(t_test, linear_pred[:, 0], 'r--', linewidth=2, label='Linear Regression Prey')
axs[2].plot(t_test, linear_pred[:, 1], 'c--', linewidth=2, label='Linear Regression Predator')
axs[2].plot(t_test, svm_pred_prey, 'm--', linewidth=2, label='SVM Prey')
axs[2].plot(t_test, svm_pred_predator, 'y--', linewidth=2, label='SVM Predator')
axs[2].set_xlabel('Time')
axs[2].set_ylabel('Population')
axs[2].legend()
axs[2].set_title('Estimates with Linear Regression and SVM')

plt.show()


```



```




```