Python KalmanFilter.filter方法代码示例

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def test_kalman_filter_update():
    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)

    # use Kalman Filter
    (x_filt, V_filt) = kf.filter(X=data.observations)

    # use online Kalman Filter
    n_timesteps = data.observations.shape[0]
    n_dim_state = data.transition_matrix.shape[0]
    x_filt2 = np.zeros((n_timesteps, n_dim_state))
    V_filt2 = np.zeros((n_timesteps, n_dim_state, n_dim_state))
    for t in range(n_timesteps - 1):
        if t == 0:
            x_filt2[0] = data.initial_state_mean
            V_filt2[0] = data.initial_state_covariance
        (x_filt2[t + 1], V_filt2[t + 1]) = kf.filter_update(
            x_filt2[t], V_filt2[t], data.observations[t + 1],
            transition_offset=data.transition_offsets[t]
        )
    assert_array_almost_equal(x_filt, x_filt2)
    assert_array_almost_equal(V_filt, V_filt2)

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def calc_slope_intercept_using_kalman_filter(etfs, prices):
    """
    Utilise the Kalman Filter from the pyKalman package
    to calculate the slope and intercept of the regressed
    ETF prices.
    """
    delta = 1e-5
    trans_cov = delta / (1 - delta) * np.eye(2)
    obs_mat = np.vstack(
        [prices[etfs[0]], np.ones(prices[etfs[0]].shape)]
    ).T[:, np.newaxis]
    
    kf = KalmanFilter(
        n_dim_obs=1, 
        n_dim_state=2,
        initial_state_mean=np.zeros(2),
        initial_state_covariance=np.ones((2, 2)),
        transition_matrices=np.eye(2),
        observation_matrices=obs_mat,
        observation_covariance=1.0,
        transition_covariance=trans_cov
    )
    
    state_means, state_covs = kf.filter(prices[etfs[1]].values)
    return state_means, state_covs

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
    def on_update(self, data):
        result = {}
        result["timestamp"] = data["timestamp"]
        if self.input.size() >= self.length:

            independent_var = self.input.get_by_idx_range(key=None, start_idx=0, end_idx=-1)
            symbol_set = set(self.input.keys)
            depend_symbol = symbol_set.difference(self.input.default_key)
            depend_var = self.input.get_by_idx_range(key=depend_symbol, start_idx=0, end_idx=-1)

            obs_mat = np.vstack([independent_var.values, np.ones(independent_var.values.shape)]).T[:, np.newaxis]
            model = KalmanFilter(
                n_dim_obs=1,
                n_dim_state=2,
                initial_state_mean=np.zeros(2),
                initial_state_covariance=np.ones((2, 2)),
                transition_matrices=np.eye(2),
                observation_matrices=obs_mat,
                observation_covariance=1.0,
                transition_covariance=self.trans_cov,
            )

            state_means, state_covs = model.filter(depend_var.values)
            slope = state_means[:, 0][-1]
            result[Indicator.VALUE] = slope
            result[KalmanFilteringPairRegression.SLOPE] = slope
            result[KalmanFilteringPairRegression.SLOPE] = state_means[:, 1][-1]
            self.add(result)

        else:
            result[Indicator.VALUE] = np.nan
            result[KalmanFilteringPairRegression.SLOPE] = np.nan
            result[KalmanFilteringPairRegression.SLOPE] = np.nan
            self.add(result)

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def KFilt(sample,fs=25):
    """Input (sample) is fill_in_data output. Outputs two lists of color data
    """
	#kalman filter inputs
    
        # Dimensions of parameters:
    # 'transition_matrices': 2,
    # 'transition_offsets': 1,
    # 'observation_matrices': 2,
    # 'observation_offsets': 1,
    # 'transition_covariance': 2,
    # 'observation_covariance': 2,
    # 'initial_state_mean': 1,
    # 'initial_state_covariance': 2,
    
    n_timesteps = len(sample)
    trans_mat = []

	#mask missing values
    observations = np.ma.array(sample,mask=np.zeros(sample.shape))
    missing_loc = np.where(np.isnan(sample))
    observations[missing_loc[0][:],missing_loc[1][:]] = np.ma.masked
	
	#Import Kalman filter, inerpolate missing points and get 2nd, 3rd orde kinematics
    dt = 1./25	#Length of each frame (should be iether 1/25 or 1/30)	
    n_timesteps = len(sample)
    
    observation_matrix = np.array([[1,0,0,0],
                                   [0,1,0,0]])#np.eye(4) 
    t = np.linspace(0,len(observations)*dt,len(observations))
    q = np.cov(observations.T[:2,:400])
    qdot = np.cov(np.diff(observations.T[:2,:400]))#np.cov(observations[:1,:400])

    h=(t[-1]-t[0])/t.shape[0]
    A=np.array([[1,0,h,.5*h**2], 
                     [0,1,0,h],  
                     [0,0,1,0],
                     [0,0,0,1]]) 

    init_mean = [sample[0],0,0] #initial mean should be close to the first point, esp if first point is human-picked and tracking starts at the beginning of a video
    observation_covariance = q*500  #ADJUST THIS TO CHANGE SMOOTHNESS OF FILTER
    init_cov = np.eye(4)*.001#*0.0026
    transition_matrix = A
    transition_covariance = np.array([[q[0,0],q[0,1],0,0],
                                      [q[1,0],q[1,1],0,0],
                                      [0,0,qdot[0,0],qdot[0,1]],
                                      [0,0,qdot[1,0],qdot[1,1]]])

    kf = KalmanFilter(transition_matrix, observation_matrix,transition_covariance,observation_covariance,n_dim_obs=2)

    kf = kf.em(observations,n_iter=1,em_vars=['transition_covariance','transition_matrix','observation_covariance'])

    #pdb.set_trace()
    
    global trans_mat, trans_cov, init_cond
    x_filt = kf.filter(observations[0])[0]#observations.T[0])[0]
    kf_means = kf.smooth(observations[0])[0]
	
    return kf_means,x_filt #np.column_stack((color_x[:,0],color_y[:,0],color_x[:,1],color_y[:,1])),frames

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
class KalmanRegression(object):
    """
    Uses a Kalman Filter to estimate regression parameters 
    in an online fashion.
    
    Estimated model: y ~ beta * x + alpha
    """
    
    def __init__(self, initial_y, initial_x, delta=1e-5, maxlen=3000):
        self._x = initial_x.name
        self._y = initial_y.name
        self.maxlen = maxlen
        trans_cov = delta / (1 - delta) * np.eye(2)
        obs_mat = np.expand_dims(
            np.vstack([[initial_x], [np.ones(initial_x.shape[0])]]).T, axis=1)
        
        self.kf = KalmanFilter(n_dim_obs=1, n_dim_state=2,
                               initial_state_mean=np.zeros(2),
                               initial_state_covariance=np.ones((2, 2)),
                               transition_matrices=np.eye(2),
                               observation_matrices=obs_mat,
                               observation_covariance=1.0,
                               transition_covariance=trans_cov)
        state_means, state_covs = self.kf.filter(initial_y.values)
        self.means = pd.DataFrame(state_means, 
                                  index=initial_y.index, 
                                  columns=['beta', 'alpha'])
        self.state_cov = state_covs[-1]
        
    def update(self, observations):
        x = observations[self._x]
        y = observations[self._y]
        mu, self.state_cov = self.kf.filter_update(
            self.state_mean, self.state_cov, y, 
            observation_matrix=np.array([[x, 1.0]]))
        mu = pd.Series(mu, index=['beta', 'alpha'], 
                       name=observations.name)
        self.means = self.means.append(mu)
        if self.means.shape[0] > self.maxlen:
            self.means = self.means.iloc[-self.maxlen:]
        
    def get_spread(self, observations):
        x = observations[self._x]
        y = observations[self._y]
        return y - (self.means.beta[-1] * x + self.means.alpha[-1])
        
    @property
    def state_mean(self):
        return self.means.iloc[-1]
        

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
	def _KalmanFilterRegression( self ):
		""" Use Kalman Filter to obtain first-order auto-regression parameters
			r_t = beta_0 + beta_1 * r_(t-1)
		"""
		returns = self.returns;
		_trans_cov_delta = 1e-3;

		# Transition matrix and covariance
		trans_mat = np.eye(2);								# Assume beta is not to change from t-1 to t
		_delta = _trans_cov_delta;										
		trans_cov = _delta / (1 - _delta) * np.eye(2);		# This _delta and trans_cov seem to have great impact on the result

		# form Observation Matrix
		data = returns.values[:-1,:];
		_, num_stocks = data.shape;

		data = np.expand_dims( data, axis = 2 );			# T-by-2-by-1 array
		obs_mat = np.insert( data, 1, 1, axis = 2 );		# Insert column of ones T-2-2 array
		obs_cov = np.eye( num_stocks );						# assume zero correlation among noises in observed stock returns

		#print "Shape of observation matrix is ", obs_mat.shape;
		#print "Example of obs_mat is ", obs_mat[:2,:,:];

		# Observed stock returns: r_t
		index = returns.index[1:];							# index for beta_1(t)
		observations = returns.values[1:,:]					# matrix of r_t

		# Form Kalman Filter and then filter!
		kf = KalmanFilter( n_dim_obs = num_stocks,
							n_dim_state = 2,				# 2 regression parameters
							initial_state_mean = np.zeros(2),
							initial_state_covariance = np.ones((2,2)),
							transition_matrices = trans_mat,
							transition_covariance = trans_cov,
							observation_matrices = obs_mat,
							observation_covariance = obs_cov,
		);

		state_means, state_covs = kf.filter( observations );

		slope = pd.Series( state_means[:,0], index );
		intercept = pd.Series( state_means[:,1], index );

		kf_coefficients_df = pd.DataFrame( [ intercept, slope ], index = [ "coeff_0", "coeff_1" ] );
		self.kf_coefficients_df = kf_coefficients_df.transpose();

		return (intercept, slope);

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def getPredictedValuesVer2(measurements, standard_deviation = None):
    #this method use PyKalman module
    #Apply this method only for Gains.
    
    if standard_deviation == None:
        #if standard deviation is not specified, then get it only from measurements list
        standard_deviation = getStandardDeviation(measurements)
        
    #adapt the transition_covariance. Temporary 
    if standard_deviation < 1e-9:
        transition_covariance = 1e-21
    else:
        transition_covariance = 5e-17
    
    kf = KalmanFilter(transition_matrices = [1], observation_matrices = [1], transition_covariance = transition_covariance, observation_covariance = math.pow(standard_deviation, 2))
    tmp= kf.filter(measurements)[0].tolist()
    for i in range(0, len(tmp)):
        tmp[i] = tmp[i][0]
    
    return tmp

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
class Regression(object):
    """
    y = beta * x + alpha
    """

    def __init__(self, initial_x, initial_y, date, delta=1e-5):
        trans_cov = delta / (1 - delta) * np.eye(2)
        xList = []
        for x in initial_x:
            xList.append([[x,1.]])
        obs_mat = np.vstack([xList])

        self.kf = KalmanFilter(n_dim_obs=1, n_dim_state=2,
                               initial_state_mean=np.zeros(2),
                               initial_state_covariance=np.ones((2, 2)),
                               transition_matrices=np.eye(2),
                               observation_matrices=obs_mat,
                               observation_covariance=1.0,
                               transition_covariance=trans_cov)
        state_means, state_covs = self.kf.filter(np.array(initial_y))
        self.means = pd.DataFrame(state_means,
                                  columns=['beta', 'alpha'])
        self.state_cov = state_covs[-1]

    def update(self, observations, date):
        x = observations[0]
        y = observations[1]
        mu, self.state_cov = self.kf.filter_update(self.state_mean, self.state_cov, y,
                                                   observation_matrix=np.array([[x, 1.0]]))
        mu = pd.Series(mu, index=['beta', 'alpha'],
                       name=date)
        self.means = self.means.append(mu)

    def get_spread(self, observations):
        x = observations[0]
        y = observations[1]
        return y - (self.means.beta * x + self.means.alpha)

    @property
    def state_mean(self):
        return self.means.iloc[-1]

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def kalman_ma(df, transition_covariance=.01):
    
    df_new = pd.DataFrame()
    
    for c in df.columns:
        
        # Construct a Kalman filter
        kf = KalmanFilter(transition_matrices = [1],
                          observation_matrices = [1],
                          initial_state_mean = df.ix[0,c],
                          initial_state_covariance = 1,
                          observation_covariance=1,
                          transition_covariance=transition_covariance)

        # Use the observed values of the price to get a rolling mean
        state_means, _ = kf.filter(df[c].values)
        df_new[c] = state_means[:,0]
    
    df_new.index = df.index
    
    return df_new

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def test_kalman_filter():
    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_filt, V_filt) = kf.filter(X=data.observations)
    assert_array_almost_equal(
        x_filt[:500],
        data.filtered_state_means[:500],
        decimal=7
    )
    assert_array_almost_equal(
        V_filt[:500],
        data.filtered_state_covariances[:500],
        decimal=7
    )

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def kalman_filtering(price_sequence):

    h = 1 #time step
    A = np.array([[1,h,.5*h**2],
                [0,1,h],
                [0,0,1]])
                
    Q = np.eye(A.shape[0])
    #2) Apply the filter    
    kf = KalmanFilter(transition_matrices = A , transition_covariance = Q)
      
    means, covariances = kf.filter([price_sequence[0]])
    
    filtered_price_sequence = [means[0,0]]
    
    for i in range(1,len(price_sequence)):
        #to track it (streaming)
        new_mean, new_covariance = kf.filter_update(means[-1], covariances[-1], price_sequence[i])
        means = np.vstack([means,new_mean])
        covariances = np.vstack([covariances,new_covariance.reshape((1,3,3))])
    
        filtered_price_sequence.append(means[i,0])
    
    return filtered_price_sequence

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
from pykalman import KalmanFilter
import numpy as np
kf = KalmanFilter(transition_matrices = [[1, 1], [0, 1]], observation_matrices = [[0.1, 0.5], [-0.3, 0.0]])
measurements = np.asarray([[1,0], [0,0], [0,1]])  # 3 observations
kf = kf.em(measurements, n_iter=5)
(filtered_state_means, filtered_state_covariances) = kf.filter(measurements)

print filtered_state_means

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
from pylab import *
from pykalman import KalmanFilter

kf = KalmanFilter();
data = loadtxt('data_gps1.txt');
lat = radians(data[0,:]);
lon = radians(data[1,:]);

dlat = lat[1:] - lat[0:-1];
dlon = lon[1:] - lon[0:-1];

R = 6373; #Radius of earth in kilometers
a = (sin(dlat/2))**2 + cos(lat[0:-1])*cos(lat[1:])*((sin(dlon/2))**2);
c = 2*arctan2(sqrt(a),sqrt(1-a));
d = R * c;

kf = kf.em(d,n_iter = 5);
(smoothed_means,smoothed_cov) = kf.smooth(d);
(filtered_means,filtered_cov) = kf.filter(d);


plot(d,label = 'Original Data');
plot(smoothed_means,label = 'Kalman Smoothed');
plot(filtered_means,label = 'Kalman Filtered');
legend();
show();

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
        # sample from model
        kf = KalmanFilter(
            transition_matrix,
            observation_matrix,
            transition_covariance,
            observation_covariance,
            transition_offset,
            observation_offset,
            initial_state_mean,
            initial_state_covariance,
        )

        # kf = kf.em(y, n_iter=5)
        taxels = tsframes3D[y, x, :]
        tsframes3D_kalman[y, x, :] = np.round(kf.filter(taxels)[0].flatten())

kalman = tsframes3D_kalman[:, :, frameID].astype(np.float32)


############################
# Spatio-Temporal Filtering
############################

# ---------------
# Kalman + Median filter
# ---------------
kalman_median = cv2.medianBlur(kalman, d)
masked = ma.masked_greater(kalman_median, 0)  # Masked where result of filter > 0
kalman_median_masked = np.copy(tsframe)
kalman_median_masked[~masked.mask] = 0

# 需要导入模块: from pykalman import KalmanFilter [as 别名]
# 或者: from pykalman.KalmanFilter import filter [as 别名]
def main():
    
    #Paramètres du modèle
    #Indiquer à quoi correspond chaque variable
    osigma=0.1;

    transition_matrix = np.array([[1., 0.,0.,0.,0.,0.],[1., 1.,0.,0.,0.,0.],[0.,0,1,0.,0.,0.]])
    transition_covariance = np.zeros((6,6));
    
    

    observation_matrix = np.array([[0., 1.,0.],[0., 0.,1.]])
    observation_covariance = np.eye(2)*osigma

    initial_state_mean = np.array([1,0,10]) # m(0)
    initial_state_covariance = np.eye(3);# p(0)
    
    
    #Observations
    observations = csv.reader(open('voitureObservations.csv','r'),delimiter=' ')
        

    # Filtrage à la main
    # Quels sont les paramètres du constructeur ?
    kf = KalmanFilter(
        transition_matrix, observation_matrix,
        transition_covariance, observation_covariance,
    )    
    
    # Que conserverons les variables suivantes ?
    hand_state_estimates=[initial_state_mean]
    hand_state_cov_estimates=[initial_state_covariance]
    
    for anObs in observations:
        # Quelles étapes du filtrage sont réalisées par la ligne suivante
        (aMean,aCov) = kf.filter_update(hand_state_estimates[-1],hand_state_cov_estimates[-1],anObs)
        hand_state_estimates.append(aMean)
        hand_state_cov_estimates.append(aCov)
    hand_state_estimates=np.array(hand_state_estimates)
    
    # A quoi sert la ligne suivante ?
    hand_positions=np.dot(hand_state_estimates,observation_matrix.T ) # obtenir les observation (H*Mk-1 dans le cours, rouge) projet mon espace etat ver mon espace observation
    
    plt.figure(1)
    plt.plot(observations[:,0],observations[:,1], 'r+')
    plt.plot(hand_positions[:,0],hand_positions[:,1], 'b')
    plt.savefig('illustration_filtrage_main_voiture.pdf')
    plt.close()


    # Filtrage complet
    # Que fait cette section ?
    # Quels sont les paramètres supplémentaires donnés au constructeur ?
    # Quels sont les autres paramètres possibles ?
    kf = KalmanFilter(
        transition_matrix, observation_matrix,
        transition_covariance, observation_covariance,
        initial_state_mean=initial_state_mean, initial_state_covariance=initial_state_covariance,
    )

    
    (filtered_state_estimates,filtered_state_cov_estimates) = kf.filter(observations)
    filtered_positions=np.dot(filtered_state_estimates,observation_matrix.T )
    
    plt.figure(1)
    plt.plot(observations[:,0],observations[:,1], 'r+')
    plt.plot(filtered_positions[:,0],filtered_positions[:,1], 'b')
    plt.savefig('illustration_filtrage_voiture.pdf')
    plt.close()

    # Lissage
    # Que fait cette section ?
    # Quel est la différence avec le filtrage ?
    # Puis-je faire un lissage "à la main" observation par observation ?
   
    kf = KalmanFilter(
        transition_matrix, observation_matrix,
        transition_covariance, observation_covariance,
        initial_state_mean=initial_state_mean, initial_state_covariance=initial_state_covariance,
    )

    (smoothed_state_estimates,smoothed_state_cov_estimates) = kf.smooth(observations) # au lieu de filtre, on appel smooth
    smoothed_positions=np.dot(smoothed_state_estimates,observation_matrix.T )
    
    plt.figure(2)
    plt.plot(observations[:,0],observations[:,1], 'r+')
    plt.plot(smoothed_positions[:,0],smoothed_positions[:,1], 'b')
    plt.savefig('illustration_lissage_voiture.pdf')
    plt.close()