def __init__(self, name, rate_limiter):
super(Leader, self).__init__(name,
rate_limiter=rate_limiter,
laser_range=[np.pi / 3.5, np.pi / 3.5],
laser_dist=2)
self._epsilon = 0.1
self.leg_pub = rospy.Publisher('/' + name + '/legs',
Marker,
queue_size=5)
self.centroid_pub = rospy.Publisher('/' + name + '/centroids',
Marker,
queue_size=5)
self.v_pub = rospy.Publisher('/' + name + '/vel', Marker, queue_size=5)
self.follow = None
self._tf = TransformListener()
self.last_vel = np.array([0., 0.])
self.all_around_laser = Laser(name=name, laser_range=[np.pi, np.pi])
self.last_legs = None
def f(state, noise):
pass
def g(state, noise):
pass
self.ukf = UnscentedKalmanFilter(f, g)
self.kf = None
def __init__(self, dimState, delay, arm, knoiseU, controller):
'''
Initializes parameters to uses the function implemented below
inputs: -dimState: dimension of the state, here the state correspond to the muscular activation vector U, int
-dimObs: dimension of the observation, here the observation is the position of the arm given by the model, int
-delay: the delay with which we give the observation to the filter, int
-arm, armModel, class object
-rs, ReadSetupFile, class object
'''
self.name = "UnscentedKalmanFilter"
self.knoiseU = knoiseU
self.dimState = dimState
self.delay = delay
self.arm = arm
self.controller = controller
#initialization of some parameters for the filter
transition_covariance = np.eye(self.dimState) * 0.01
initial_state_mean = np.zeros(self.dimState)
observation_covariance = 1000 * np.eye(self.dimState)
initial_state_covariance = np.eye(self.dimState)
self.nextCovariance = np.eye(self.dimState) * 0.0001
self.ukf = UnscentedKalmanFilter(self.transitionFunctionUKF,
self.observationFunctionUKF,
transition_covariance,
observation_covariance,
initial_state_mean,
initial_state_covariance)
def __init__(self):
initialState = np.zeros((6, 1))
initialCov = np.diag(np.ones((6, 1))[:, 0])
self.filter = UnscentedKalmanFilter(
initial_state_mean=initialState,
initial_state_covariance=initialCov,
n_dim_obs=6)
def test_kalman2():
from pykalman import UnscentedKalmanFilter
ukf = UnscentedKalmanFilter(lambda x, w: x + np.sin(w),
lambda x, v: x + v,
transition_covariance=0.1)
(filtered_state_means, filtered_state_covariances) = ukf.filter([0, 1, 2])
(smoothed_state_means, smoothed_state_covariances) = ukf.smooth([0, 1, 2])
def kalman_filter(seq):
def f(state, noise):
return state + np.sin(noise)
def g(state, noise):
return state + np.cos(noise)
# kf = KalmanFilter(initial_state_mean=0, n_dim_obs=2)
ukf = UnscentedKalmanFilter(f, g, 0.001)
return ukf.smooth(seq)[0].T[0]
def kalman_feat(df, cols):
for col in cols:
ukf = UnscentedKalmanFilter(lambda x, w: x + np.sin(w),
lambda x, v: x + v,
observation_covariance=0.1)
(filtered_state_means,
filtered_state_covariances) = ukf.filter(df[col])
(smoothed_state_means,
smoothed_state_covariances) = ukf.smooth(df[col])
df[col + "_UKFSMOOTH"] = smoothed_state_means.flatten()
df[col + "_UKFFILTER"] = filtered_state_means.flatten()
return df
def kalmanFilter(X):
ukf = UnscentedKalmanFilter()
X_fil = np.zeros(np.shape(X))
for i in range(np.shape(X)[1]):
X_fil[:, i] = ukf.smooth(X[:, i])[0].ravel()
return X_fil
#if __name__ == "__main__":
#
# subject = 'qing_frontal_3.7'
# X,y= fetchDataset(subject)
#
# seq_x, seq,y = split_sequences(s, n_steps):
## X_train,X_test,y_train,y_test = split_train_test(X,y)
def __init__(self, x, v, w):
self.random_state = np.random.RandomState(0)
self.transition_covariance = np.array([[0.5, 0, 0, 0, 0],\
[0, 1, 0, 0, 0],\
[0, 0, 0.1, 0, 0],\
[0, 0, 0, 0.001, 0],\
[0, 0, 0, 0, 0.001],\
])
self.observation_covariance = np.array([[0.5, 0, 0, 0, 0],\
[0, 1, 0, 0, 0],\
[0, 0, 0.5, 0, 0],\
[0, 0, 0, 0.001, 0],\
[0, 0, 0, 0, 0.001],\
])
self.initial_state_mean = [x, 0.1, v, np.pi / 2, w]
# self.initial_state_mean = [0, 0, 20, 0, np.pi / 180]
self.transition_state = self.initial_state_mean
self.obs = self.initial_state_mean
self.pre_parabola_param = [0, 0, 1.75]
self.initial_state_covariance = np.array([[0.5, 0, 0, 0, 0],\
[0, 0.02, 0, 0, 0],\
[0, 0, 0.1, 0, 0],\
[0, 0, 0, 0.001, 0],\
[0, 0, 0, 0, 0.001],\
])
self.T = 0.5
self.estimate_state = [
self.initial_state_mean, self.initial_state_covariance
]
self.kf = UnscentedKalmanFilter(self.transition_function,
self.observation_function,
self.transition_covariance,
self.observation_covariance,
self.initial_state_mean,
self.initial_state_covariance,
random_state=self.random_state)
self.timestamp = time.time()
def kalman_filter(video_file, dep0, v0):
# get feature points from video
points, init_image = get_feature_points_from_video(video_file)
i, o = feature_points_to_observation_and_initilization(points, v0, dep0)
# number of the features points
observations = np.asarray(o)
n = observations.shape[1]
print('initilization shape is ', i.shape)
print('observation shape is ', observations.shape)
# initialize the vovariance and mean
transition_covariance = np.eye(2*n+6)
random_state = np.random.RandomState(0)
observation_covariance = np.eye(n) + abs(random_state.randn(n, n) * 0.005)
initial_state_mean = i
covariance_init = random_state.randn(2*n+6, 2*n+6) * 0.2
covariance_init[0:3,0:3] = 0.005
initial_state_covariance = np.eye(2*n+6) + abs(covariance_init)
# set Unscented kalman filter
kf = UnscentedKalmanFilter(
transition_function, observation_function,
transition_covariance, observation_covariance,
initial_state_mean, initial_state_covariance,
random_state=random_state
)
"""
kf = AdditiveUnscentedKalmanFilter(
additive_transition_function, additive_observation_function,
transition_covariance, observation_covariance,
initial_state_mean, initial_state_covariance
)
"""
# get result
filtered_state_estimates = kf.filter(observations)
smoothed_state_estimates = kf.smooth(observations)
return filtered_state_estimates, smoothed_state_estimates
GPScord = []
for d in data:
temp = d.split(',')
temp2 = []
temp2.append(float(temp[1][2:][:-1]))
temp2.append(float(temp[2][2:][:-1]))
temp2.append(float(temp[3][2:][:-2]))
GPScord.append(temp2)
#for record in GPScord:
# print record
from pykalman import KalmanFilter
from pykalman import UnscentedKalmanFilter
#kf = KalmanFilter(n_dim_obs=3)
kf = KalmanFilter(transition_matrices=[[1, 1], [0, 1]],
observation_matrices=[[0.1, 0.5], [-0.3, 0.0]])
kf2 = UnscentedKalmanFilter()
measurements = GPScord
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
lat = []
lon = []
alt = []
for sample in GPScord:
lat.append(sample[0])
lon.append(sample[1])
alt.append(sample[2])
ax.scatter(lat, lon, alt, c='r', marker='o', s=10)
ax.plot(lat, lon, alt)
ax.set_xlabel('X Label')
def additive_observation_function(state):
return observation_function(state, np.array([0, 0]))
transition_covariance = np.eye(2)
random_state = np.random.RandomState(0)
observation_covariance = np.eye(2) + random_state.randn(2, 2) * 0.1
initial_state_mean = [0, 0]
initial_state_covariance = [[1, 0.1], [0.1, 1]]
# sample from model
ukf = UnscentedKalmanFilter(transition_function,
observation_function,
transition_covariance,
observation_covariance,
initial_state_mean,
initial_state_covariance,
random_state=random_state)
akf = AdditiveUnscentedKalmanFilter(additive_transition_function,
additive_observation_function,
transition_covariance,
observation_covariance, initial_state_mean,
initial_state_covariance)
states, observations = ukf.sample(50, initial_state_mean)
# estimate state with filtering
ukf_state_estimates = ukf.filter(observations)[0]
akf_state_estimates = akf.filter(observations)[0]
# draw estimates
def test_unscented_kalman(self):
ukf = UnscentedKalmanFilter(lambda x, w: x + np.sin(w), lambda x, v: x + v, transition_covariance=0.1)
(filtered_state_means, filtered_state_covariances) = ukf.filter([0, 1, 2])
(smoothed_state_means, smoothed_state_covariances) = ukf.smooth([0, 1, 2])
return filtered_state_means
def main(argv):
config = read_parser(argv, Inputs, InputsOpt_Defaults)
if config['mode'] == 'fuse_kalman':
print('Select MASTER Features xls')
root = Tk()
root.withdraw()
root.update()
filepath = filedialog.askopenfilename()
root.destroy()
mydict = pd.read_excel(filepath)
rownames = list(mydict.index.values)
length_data = len(rownames)
mydict = mydict.to_dict(orient='list')
newdict = {}
for key, values in mydict.items():
newdict[key] = movil_avg(mydict[key], config['n_mov_avg'])
Features = []
for i in range(length_data):
example = []
for feature in config['feature_array']:
example.append(newdict[feature][i])
Features.append(example)
Features = np.array(Features)
plt.plot(Features)
plt.show()
scaler_model = StandardScaler()
scaler_model.fit(Features)
Features = scaler_model.transform(Features)
plt.plot(Features)
plt.show()
kf = UnscentedKalmanFilter(n_dim_state=1,
n_dim_obs=len(config['feature_array']),
random_state=1)
# kf = AdditiveUnscentedKalmanFilter(n_dim_state=1, n_dim_obs=6, random_state=1)
# kf = KalmanFilter(n_dim_state=1, n_dim_obs=len(config['feature_array']), random_state=1)
measurements = [i for i in Features]
# kf.em(measurements)
z = kf.smooth(measurements)
z = z[0]
plt.plot(z)
plt.show()
elif config['mode'] == 'testtt':
if config['mypath'] == None:
print('Select XLS Files with Feature')
root = Tk()
root.withdraw()
root.update()
Filepaths = filedialog.askopenfilenames()
root.destroy()
else:
# Filepath = config['mypath']
Filepaths = [
join(config['mypath'], f) for f in listdir(config['mypath'])
if isfile(join(config['mypath'], f)) if f[-4:] == 'xlsx'
]
Feature = []
for filepath in Filepaths:
mydict = pd.read_excel(filepath)
mydict = mydict.to_dict(orient='list')
Feature += mydict[config['feature']]
Feature = np.array(Feature)
for i in range(len(Feature)):
count = 0
while np.isnan(Feature[i]) == True:
count += 1
Feature[i] = Feature[i + count]
# Feature = np.nan_to_num(Feature)
Feature = movil_avg(Feature, config['n_mov_avg'])
plt.plot(Feature)
plt.show()
elif config['mode'] == 'fuse_factor':
print('Select MASTER Features xls')
root = Tk()
root.withdraw()
root.update()
filepath = filedialog.askopenfilename()
root.destroy()
mydict = pd.read_excel(filepath)
rownames = list(mydict.index.values)
length_data = len(rownames)
mydict = mydict.to_dict(orient='list')
newdict = {}
for key, values in mydict.items():
newdict[key] = movil_avg(mydict[key], config['n_mov_avg'])
Features = []
for i in range(length_data):
example = []
for feature in config['feature_array']:
example.append(newdict[feature][i])
Features.append(example)
Features = np.array(Features)
plt.plot(Features)
plt.show()
scaler_model = StandardScaler()
scaler_model.fit(Features)
Features = scaler_model.transform(Features)
plt.plot(Features)
plt.show()
fa = FactorAnalysis(n_components=1, random_state=1)
fa.fit(Features)
z = fa.transform(Features)
plt.plot(z)
plt.show()
elif config['mode'] == 'fuse_pca':
print('Select MASTER Features xls')
root = Tk()
root.withdraw()
root.update()
filepath = filedialog.askopenfilename()
root.destroy()
mydict = pd.read_excel(filepath)
rownames = list(mydict.index.values)
length_data = len(rownames)
mydict = mydict.to_dict(orient='list')
newdict = {}
for key, values in mydict.items():
newdict[key] = movil_avg(mydict[key], config['n_mov_avg'])
Features = []
for i in range(length_data):
example = []
for feature in config['feature_array']:
example.append(newdict[feature][i])
Features.append(example)
Features = np.array(Features)
plt.plot(Features)
plt.show()
scaler_model = StandardScaler()
scaler_model.fit(Features)
Features = scaler_model.transform(Features)
plt.plot(Features)
plt.show()
from sklearn.cluster import FeatureAgglomeration
from sklearn.decomposition import FastICA
from sklearn.decomposition import KernelPCA
FeatureAgglomeration
# model = PCA(n_components=len(config['feature_array']))
model = PCA(n_components=2)
# model = FeatureAgglomeration(n_clusters=1)
# model = FastICA(n_components=1)
# model = KernelPCA(n_components=1, kernel='rbf')
# model = KernelPCA(n_components=len(config['feature_array']), kernel='rbf')
model.fit(Features)
Features = model.transform(Features)
print(model.explained_variance_)
print(model.explained_variance_ratio_)
plt.plot(Features)
plt.show()
# TFeatures = np.transpose(Features)
# plt.plot(TFeatures[0])
# plt.show()
# mydict_out = {}
# mydict_out['FuFFT_ma1'] = TFeatures[0]
# writer = pd.ExcelWriter('MASTER_Features.xlsx')
# DataFr = pd.DataFrame(data=mydict_out, index=rownames)
# DataFr.to_excel(writer, sheet_name='AE_Features')
# writer.close()
elif config['mode'] == 'fuse_corr':
print('Select MASTER Features xls')
root = Tk()
root.withdraw()
root.update()
filepath = filedialog.askopenfilename()
root.destroy()
mydict = pd.read_excel(filepath)
rownames = list(mydict.index.values)
length_data = len(rownames)
mydict = mydict.to_dict(orient='list')
Features = {}
for key, values in mydict.items():
Features[key] = movil_avg(mydict[key], config['n_mov_avg'])
CorrCoefs = {}
for feature1 in config['feature_array']:
mylist = []
for feature2 in config['feature_array']:
value = np.corrcoef(Features[feature1],
Features[feature2])[0][1]
mylist.append(value)
CorrCoefs[feature1] = mylist
writer = pd.ExcelWriter('Corr_Features.xlsx')
DataFr = pd.DataFrame(data=CorrCoefs, index=config['feature_array'])
DataFr.to_excel(writer, sheet_name='Corr_Features')
writer.close()
elif config['mode'] == 'test_cluster':
print('Select MASTER Features xls')
root = Tk()
root.withdraw()
root.update()
filepath = filedialog.askopenfilename()
root.destroy()
mydict = pd.read_excel(filepath)
rownames = list(mydict.index.values)
length_data = len(rownames)
mydict = mydict.to_dict(orient='list')
newdict = {}
for key, values in mydict.items():
newdict[key] = movil_avg(mydict[key], config['n_mov_avg'])
Features = []
for i in range(length_data):
example = []
for feature in config['feature_array']:
example.append(newdict[feature][i])
Features.append(example)
Features = np.array(Features)
from sklearn.cluster import DBSCAN, AffinityPropagation
model = AffinityPropagation()
print(model.fit_predict(Features))
elif config['mode'] == 'fuse_mlp':
print('Select MASTER Features xls')
root = Tk()
root.withdraw()
root.update()
filepath = filedialog.askopenfilename()
root.destroy()
mydict = pd.read_excel(filepath)
rownames = list(mydict.index.values)
length_data = len(rownames)
mydict = mydict.to_dict(orient='list')
newdict = {}
for key, values in mydict.items():
newdict[key] = movil_avg(mydict[key], config['n_mov_avg'])
Features = []
for i in range(length_data):
example = []
for feature in config['feature_array']:
example.append(newdict[feature][i])
Features.append(example)
Features = np.array(Features)
plt.plot(Features)
plt.show()
scaler_model = StandardScaler()
scaler_model.fit(Features)
Features = scaler_model.transform(Features)
plt.plot(Features)
plt.show()
nn = MLPRegressor(hidden_layer_sizes=(5),
activation='tanh',
solver='lbfgs0',
alpha=1.e1)
nn.fit(X=Features, y=np.linspace(0, 1, length_data))
z = nn.predict(Features)
# Features = pca.transform(Features)
# corr = []
# TFeatures = np.transpose(Features)
# for feature_pca in TFeatures:
# corr.append(np.corrcoef(np.ravel(feature_pca), np.arange(len(feature_pca)))[0][1])
# z = TFeatures[np.argmax(np.absolute(corr))]
# print(corr)
plt.plot(z)
plt.show()
elif config['mode'] == 'predict_from_xls_mlp':
print('Select xls')
root = Tk()
root.withdraw()
root.update()
Filepaths = filedialog.askopenfilenames()
root.destroy()
Feature = []
for filepath in Filepaths:
mydict = pd.read_excel(filepath, sheetname=config['sheet'])
mydict = mydict.to_dict(orient='list')
# Feature += mydict[config['feature']][:-2]
Feature += mydict[config['feature']]
Feature = list(np.nan_to_num(Feature))
Feature = movil_avg(Feature, config['n_mov_avg'])
Feature = np.array(Feature)
# fig, ax = plt.subplots(nrows=2, ncols=1, sharex=True, sharey=True)
# ax[0].plot(Feature, 'r')
Feature = median_filter(data=Feature, points=5, same_length=True)
# ax[1].plot(Feature, 'b')
# plt.show()
x_Feature = np.arange(len(Feature))
Train = Feature[0:int(config['train'] * len(Feature))]
x_Train = np.arange(float(len(Train)))
x_Predict = np.linspace(len(Train),
len(Feature),
num=len(Feature) - len(Train),
endpoint=False)
# scaler = StandardScaler()
# scaler = RobustScaler()
# scaler.fit(Train)
# Train = scaler.transform(Train)
clf = MLPRegressor(solver=config['solver'],
alpha=config['alpha'],
hidden_layer_sizes=config['layers'],
random_state=config['rs'],
activation=config['activation'],
tol=config['tol'],
verbose=True,
max_iter=config['max_iter'])
# from sklearn.tree import DecisionTreeRegressor
# clf = DecisionTreeRegressor()
n_pre = int(config['n_pre'] * len(Train))
m_post = int(config['m_post'] * len(Train))
n_ex = len(Train) - n_pre - m_post
print('+++++++++++++Info: Input points n = ', n_pre)
print('+++++++++++++Info: Output points m = ', m_post)
print('+++++++++++++Info: Training examples = ', n_ex)
a = input('enter to continue...')
T_Inputs = []
T_Outputs = []
# plt.plot(Train, 'k')
# plt.show()
for k in range(n_ex + 1):
T_Inputs.append(Train[k:k + n_pre])
T_Outputs.append(Train[k + n_pre:k + n_pre + m_post])
# aa = np.arange(len(Train[k : k + n_pre]))
# plt.plot(aa, Train[k : k + n_pre], 'b')
# bb = np.max(aa) + np.arange(len(Train[k + n_pre : k + n_pre + m_post]))
# plt.plot(bb, Train[k + n_pre : k + n_pre + m_post], 'r')
# plt.show()
# sys.exit()
from sklearn.model_selection import KFold, GroupKFold
kf = KFold(n_splits=100, shuffle=True)
# X = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16], [17, 19]])
# y = np.array([[3], [5], [7], [9], [11], [13], [15], [17], [19]])
# # X = T_Inputs
# # y = T_Outputs
# for i in range(3):
# for train_index, test_index in kf.split(X):
# print("TRAIN:", train_index, "TEST:", test_index)
# # X_train, X_test = X[train_index], X[test_index]
# # y_train, y_test = y[train_index], y[test_index]
# sys.exit()
T_Inputs = np.array(T_Inputs)
T_Outputs = np.array(T_Outputs)
count = 0
epochs = 10
for i in range(epochs):
print(
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++Epoch',
count)
numb = 0
for train_index, test_index in kf.split(T_Inputs):
print('+++++++++++Batch', numb)
T_Inputs_train, T_Inputs_test = T_Inputs[
train_index], T_Inputs[test_index]
T_Outputs_train, T_Outputs_test = T_Outputs[
train_index], T_Outputs[test_index]
clf.partial_fit(T_Inputs_test, T_Outputs_test)
numb += 1
count += 1
# clf.fit(T_Inputs, T_Outputs)
print(
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n'
)
Predict = []
It_Train = list(Train)
for k in range(len(x_Predict) + m_post - 1):
P_Input = It_Train[n_ex + k + 1:n_ex + n_pre + k + 1]
P_Output = clf.predict([P_Input])
P_Output = P_Output[0]
Predict.append(P_Output[-1])
It_Train.append(P_Output[-1])
Predict = Predict[:-(m_post - 1)]
fig, ax = plt.subplots()
ax.set_xlabel('Accumulated Operating Hours', fontsize=13)
ax.set_ylabel('Health Index', fontsize=13)
ax.set_title('Linear Regression', fontsize=13)
fact = 5. / 3600.
ax.plot(x_Feature * fact, Feature, 'b', label='Real')
ax.plot(x_Predict * fact, Predict, 'r', label='Prediction')
ax.plot(x_Train * fact, Train, 'k', label='Training')
ax.legend()
plt.show()
plt.plot(x_Feature, Feature, 'b', x_Predict, Predict, 'r', x_Train,
Train, 'k')
plt.show()
# elif config['mode'] == 'predict_from_xls_mlp':
# print('Select xls')
# root = Tk()
# root.withdraw()
# root.update()
# Filepaths = filedialog.askopenfilenames()
# root.destroy()
# Feature = []
# for filepath in Filepaths:
# mydict = pd.read_excel(filepath, sheetname=config['sheet'])
# mydict = mydict.to_dict(orient='list')
# # Feature += mydict[config['feature']][:-2]
# Feature += mydict[config['feature']]
# Feature = list(np.nan_to_num(Feature))
# Feature = movil_avg(Feature, config['n_mov_avg'])
# Feature = np.array(Feature)
# # fig, ax = plt.subplots(nrows=2, ncols=1, sharex=True, sharey=True)
# # ax[0].plot(Feature, 'r')
# Feature = median_filter(data=Feature, points=5, same_length=True)
# # ax[1].plot(Feature, 'b')
# # plt.show()
# x_Feature = np.arange(len(Feature))
# Train = Feature[0:int(config['train']*len(Feature))]
# x_Train = np.arange(float(len(Train)))
# x_Predict = np.linspace(len(Train), len(Feature), num=len(Feature) - len(Train), endpoint=False)
# # scaler = StandardScaler()
# # scaler = RobustScaler()
# # scaler.fit(Train)
# # Train = scaler.transform(Train)
# clf = MLPRegressor(solver=config['solver'], alpha=config['alpha'], hidden_layer_sizes=config['layers'], random_state=config['rs'], activation=config['activation'], tol=config['tol'], verbose=True, max_iter=config['max_iter'])
# # from sklearn.tree import DecisionTreeRegressor
# # clf = DecisionTreeRegressor()
# n_pre = int(config['n_pre']*len(Train))
# m_post = int(config['m_post']*len(Train))
# n_ex = len(Train) - n_pre - m_post
# print('+++++++++++++Info: Input points n = ', n_pre)
# print('+++++++++++++Info: Output points m = ', m_post)
# print('+++++++++++++Info: Training examples = ', n_ex)
# a = input('enter to continue...')
# T_Inputs = []
# T_Outputs = []
# # plt.plot(Train, 'k')
# # plt.show()
# for k in range(n_ex + 1):
# T_Inputs.append(Train[k : k + n_pre])
# T_Outputs.append(Train[k + n_pre : k + n_pre + m_post])
# # aa = np.arange(len(Train[k : k + n_pre]))
# # plt.plot(aa, Train[k : k + n_pre], 'b')
# # bb = np.max(aa) + np.arange(len(Train[k + n_pre : k + n_pre + m_post]))
# # plt.plot(bb, Train[k + n_pre : k + n_pre + m_post], 'r')
# # plt.show()
# # sys.exit()
# from sklearn.model_selection import KFold, GroupKFold
# kf = KFold(n_splits=100, shuffle=True)
# # X = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16], [17, 19]])
# # y = np.array([[3], [5], [7], [9], [11], [13], [15], [17], [19]])
# # # X = T_Inputs
# # # y = T_Outputs
# # for i in range(3):
# # for train_index, test_index in kf.split(X):
# # print("TRAIN:", train_index, "TEST:", test_index)
# # # X_train, X_test = X[train_index], X[test_index]
# # # y_train, y_test = y[train_index], y[test_index]
# # sys.exit()
# T_Inputs = np.array(T_Inputs)
# T_Outputs = np.array(T_Outputs)
# count = 0
# epochs = 10
# for i in range(epochs):
# print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++Epoch', count)
# numb = 0
# for train_index, test_index in kf.split(T_Inputs):
# print('+++++++++++Batch', numb)
# T_Inputs_train, T_Inputs_test = T_Inputs[train_index], T_Inputs[test_index]
# T_Outputs_train, T_Outputs_test = T_Outputs[train_index], T_Outputs[test_index]
# clf.partial_fit(T_Inputs_test, T_Outputs_test)
# numb += 1
# count += 1
# # clf.fit(T_Inputs, T_Outputs)
# print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n')
# Predict = []
# It_Train = list(Train)
# for k in range(len(x_Predict) + m_post - 1):
# P_Input = It_Train[n_ex + k + 1 : n_ex + n_pre + k + 1]
# P_Output = clf.predict([P_Input])
# P_Output = P_Output[0]
# Predict.append(P_Output[-1])
# It_Train.append(P_Output[-1])
# Predict = Predict[:-(m_post-1)]
# fig, ax = plt.subplots()
# ax.set_xlabel('Accumulated Operating Hours', fontsize=13)
# ax.set_ylabel('Health Index', fontsize=13)
# ax.set_title('Linear Regression', fontsize=13)
# fact = 5./3600.
# ax.plot(x_Feature*fact, Feature, 'b', label='Real')
# ax.plot(x_Predict*fact, Predict, 'r', label='Prediction')
# ax.plot(x_Train*fact, Train, 'k', label='Training')
# ax.legend()
# plt.show()
# plt.plot(x_Feature, Feature, 'b', x_Predict, Predict, 'r', x_Train, Train, 'k')
# plt.show()
elif config['mode'] == 'predict_from_xls_svr':
print('Select xls')
root = Tk()
root.withdraw()
root.update()
Filepaths = filedialog.askopenfilenames()
root.destroy()
Feature = []
for filepath in Filepaths:
mydict = pd.read_excel(filepath, sheetname=config['sheet'])
mydict = mydict.to_dict(orient='list')
Feature += mydict[config['feature']]
Feature = list(np.nan_to_num(Feature))
Feature = movil_avg(Feature, config['n_mov_avg'])
Feature = np.array(Feature)
x_Feature = np.arange(len(Feature))
Train = Feature[0:int(config['train'] * len(Feature))]
x_Train = np.arange(float(len(Train)))
x_Predict = np.linspace(len(Train),
len(Feature),
num=len(Feature) - len(Train),
endpoint=False)
# scaler = StandardScaler()
# scaler = RobustScaler()
# scaler.fit(Train)
# Train = scaler.transform(Train)
# clf = NuSVR(nu=0.5, C=1.0, kernel='poly')
clf = SVR(kernel='poly', verbose=True, degree=6, C=0.5)
n_pre = int(config['n_pre'] * len(Train))
m_post = 1
# m_post = int(config['m_post']*len(Train))
n_ex = len(Train) - n_pre - m_post
print('+++++++++++++Info: Input points n = ', n_pre)
print('+++++++++++++Info: Output points m = ', m_post)
print('+++++++++++++Info: Training examples = ', n_ex)
a = input('enter to continue...')
T_Inputs = []
T_Outputs = []
for k in range(n_ex + 1):
T_Inputs.append(Train[k:k + n_pre])
T_Outputs.append(Train[k + n_pre:k + n_pre + m_post])
clf.fit(T_Inputs, T_Outputs)
print(
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n'
)
Predict = []
It_Train = list(Train)
for k in range(len(x_Predict) + m_post - 1):
P_Input = It_Train[n_ex + k + 1:n_ex + n_pre + k + 1]
P_Output = clf.predict([P_Input])
P_Output = P_Output[0]
Predict.append(P_Output)
It_Train.append(P_Output)
# Predict = Predict[:-(m_post-1)]
fig, ax = plt.subplots()
ax.set_xlabel('Accumulated Operating Hours', fontsize=13)
ax.set_ylabel('Health Index', fontsize=13)
ax.set_title('Linear Regression', fontsize=13)
fact = 5. / 3600.
ax.plot(x_Feature * fact, Feature, 'b', label='Real')
ax.plot(x_Predict * fact, Predict, 'r', label='Prediction')
ax.plot(x_Train * fact, Train, 'k', label='Training')
ax.legend()
plt.show()
# plt.plot(x_Feature, Feature, 'b', x_Predict, Predict, 'r', x_Train, Train, 'k')
# plt.show()
elif config['mode'] == 'predict_from_xls_lin':
print('Select xls')
root = Tk()
root.withdraw()
root.update()
Filepaths = filedialog.askopenfilenames()
root.destroy()
Feature = []
for filepath in Filepaths:
mydict = pd.read_excel(filepath, sheetname=config['sheet'])
mydict = mydict.to_dict(orient='list')
Feature += mydict[config['feature']]
Feature = list(np.nan_to_num(Feature))
Feature = movil_avg(Feature, config['n_mov_avg'])
# Feature = median_filter(data=Feature, points=5, same_length=True)
Feature = np.array(Feature)
x_Feature = np.arange(len(Feature))
Train = Feature[0:int(config['train'] * len(Feature))]
x_Train = np.arange(float(len(Train)))
slope, intercept, r_value, p_value, std_err = stats.linregress(
x_Train, Train)
x_Predict = np.linspace(len(Train),
len(Feature),
num=len(Feature) - len(Train),
endpoint=False)
Predict = slope * x_Predict + intercept
fig, ax = plt.subplots()
ax.set_xlabel('Accumulated Operating Hours', fontsize=13)
ax.set_ylabel('Health Index', fontsize=13)
# ax.set_title('Linear Regression', fontsize=13)
ax.set_title('Neural Network', fontsize=13)
fact = 5. / 3600.
ax.plot(x_Feature * fact, Feature, 'b', label='Real')
ax.plot(x_Predict * fact, Predict, 'r', label='Prediction')
ax.plot(x_Train * fact, Train, 'k', label='Training')
ax.legend()
plt.show()
print(len(Feature))
else:
print('unknown mode')
sys.exit()
return
from pykalman import UnscentedKalmanFilter
import numpy as np
ukf = UnscentedKalmanFilter(lambda x, w: x + np.sin(w),
lambda x, v: x + v,
observation_covariance=0.1)
(filtered_state_means, filtered_state_covariance) = ukf.filter([0, 0, 0])
(smoothed_state_means, smoothed_state_covariance) = ukf.smooth([0, 0, 0])
def smothingData(args):
delta = ukf.smooth(args)[0]
return delta
def filteringData(args):
alpha = ukf.filter(args)
return alpha
def filtering(timeseries=None, filterType='highPassRealTime'):
'''
filterType can be
highPassRealTime
highPassBetweenRuns
UnscentedKalmanFilter_filter # documentation: https://pykalman.github.io/
UnscentedKalmanFilter_smooth
KalmanFilter_filter
KalmanFilter_smooth
noFilter
'''
timeseries = timeseries.astype(np.float)
oldShape = timeseries.shape
timeseries = timeseries.reshape(timeseries.shape[0], -1)
if filterType == 'highPassRealTime':
# from highpassFunc import highPassRealTime, highPassBetweenRuns
from highpass import highpass
def highPassRealTime(A_matrix, TR, cutoff):
full_matrix = np.transpose(
highpass(np.transpose(A_matrix), cutoff / (2 * TR), True))
return full_matrix[-1, :]
filtered_timeseries = []
for currTR in range(timeseries.shape[0]):
filtered_timeseries.append(
highPassRealTime(timeseries[:(currTR + 1)], 1.5, 56))
filtered_timeseries = np.asarray(filtered_timeseries)
elif filterType == 'highPassBetweenRuns':
# from highpassFunc import highPassRealTime, highPassBetweenRuns
from highpass import highpass
def highPassBetweenRuns(A_matrix, TR, cutoff):
return np.transpose(
highpass(np.transpose(A_matrix), cutoff / (2 * TR), False))
filtered_timeseries = highPassBetweenRuns(timeseries, 1.5, 56)
elif filterType == 'UnscentedKalmanFilter_filter':
from pykalman import UnscentedKalmanFilter
ukf = UnscentedKalmanFilter(lambda x, w: x + np.sin(w),
lambda x, v: x + v,
observation_covariance=0.1)
filtered_timeseries = np.zeros(timeseries.shape)
for curr_voxel in range(timeseries.shape[1]):
(filtered_timeseries_state_means,
filtered_timeseries_state_covariances) = ukf.filter(
timeseries[:, curr_voxel])
filtered_timeseries[:,
curr_voxel] = filtered_timeseries_state_means.reshape(
-1)
elif filterType == 'UnscentedKalmanFilter_smooth':
from pykalman import UnscentedKalmanFilter
ukf = UnscentedKalmanFilter(lambda x, w: x + np.sin(w),
lambda x, v: x + v,
observation_covariance=0.1)
filtered_timeseries = np.zeros(timeseries.shape)
for curr_voxel in range(timeseries.shape[1]):
(smoothed_state_means,
smoothed_state_covariances) = ukf.smooth(data)
filtered_timeseries[:,
curr_voxel] = smoothed_state_means.reshape(
-1)
elif filterType == 'KalmanFilter_filter':
from pykalman import KalmanFilter
kf = KalmanFilter(transition_matrices=None,
observation_matrices=None)
filtered_timeseries = np.zeros(timeseries.shape)
for curr_voxel in range(timeseries.shape[1]):
measurements = np.asarray(timeseries[:, curr_voxel])
kf = kf.em(measurements, n_iter=5)
(filtered_state_means,
filtered_state_covariances) = kf.filter(measurements)
filtered_timeseries[:,
curr_voxel] = filtered_state_means.reshape(
-1)
elif filterType == 'KalmanFilter_smooth':
from pykalman import KalmanFilter
kf = KalmanFilter(transition_matrices=None,
observation_matrices=None)
filtered_timeseries = np.zeros(timeseries.shape)
for curr_voxel in range(timeseries.shape[1]):
measurements = np.asarray(timeseries[:, curr_voxel])
kf = kf.em(measurements, n_iter=5)
(smoothed_state_means,
smoothed_state_covariances) = kf.smooth(measurements)
filtered_timeseries[:,
curr_voxel] = smoothed_state_means.reshape(
-1)
elif filterType == 'noFilter':
filtered_timeseries = timeseries
else:
raise Exception('filterType wrong')
filtered_timeseries = filtered_timeseries.reshape(oldShape)
return filtered_timeseries
ym = np.sin(state[0]) + noise[1]
return np.array([xm, ym])
'''----INITIALIZE THE PARAMETERS----'''
transition_covariance = np.eye(2)
noise_generator = np.random.RandomState(0)
observation_covariance = np.eye(2) + noise_generator.randn(2, 2) * 0.1
Initial_state = [0, 0]
intial_covariance = [[1, 0.1], [-0.1, 1]]
# UKF
kf = UnscentedKalmanFilter(transition_function,
observation_function,
transition_covariance,
observation_covariance,
Initial_state,
intial_covariance,
random_state=noise_generator)
sample = 200
states, observations = kf.sample(sample, Initial_state)
# estimate state with filtering and smoothing
filtered_state_estimates = kf.filter(observations)[0]
smoothed_state_estimates = kf.smooth(observations)[0]
# True line
t = np.linspace(0, sample * 0.1, sample)
y = np.sin(t)
plt.plot(filtered_state_estimates[:, 0],
import numpy as np
import pandas as pd
from matplotlib import cm, pyplot as plt
from pykalman import UnscentedKalmanFilter
from hmmlearn.hmm import GaussianHMM
ukf = UnscentedKalmanFilter(initial_state_mean=0, n_dim_obs=1)
def smooth(df, colname):
df[colname + '_smoothed'] = ukf.smooth(df[colname].values)[0]
return df
def parse_fmftime(namestring):
fn = namestring.split('/')[-1]
exp_id, CAMN, DATE, TIME = fn.split('_', 3)
FLY_ID = exp_id + '_' + DATE + '_' + TIME
fmftime = pd.to_datetime(DATE + TIME)
return FLY_ID, fmftime, exp_id
treatments = ['00','11','15','65']
genotypes = ['DB072','DB185','DB213']
if __name__ == "__main__":
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--flymad_dir', type=str, required=True,
help='directory of flymad files')
parser.add_argument('--parameters', type=list, required=True,
help='parameters to define HMM')
