def main():
if db in [
'lorenz', 'chua', 'duffing', 'nose_hoover', 'rikitake', 'rossler',
'wang'
]:
x, y, z = tsg.chaoticSystem(samples=samples, systemType=db)
ux = np.array([x[i - L:i] for i in range(L, len(x))])
uy = np.array([y[i - L:i] for i in range(L, len(y))])
u = np.concatenate((ux, uy), axis=1) # INPUT
d = np.array([z[i] for i in range(L, len(z))]).reshape(-1, 1)
dmin = d.min() - (d.max() - d.min()) * 0.1
dmax = d.max() + (d.max() - d.min()) * 0.1
print('Input', u.shape, 'Output', d.shape)
else:
print('Unknown dataset')
return
if kaf == 'KRLS_ALD':
from KAF import KRLS_ALD
f = KRLS_ALD(sigma=sigma, epsilon=eps)
elif kaf == 'QKLMS_AKB':
from KAF import QKLMS_AKB
f = QKLMS_AKB(sigma_init=sigma, epsilon=eps, K=5)
elif kaf == 'ALDKRLS_AKB_2':
from KAF import ALDKRLS_AKB_2
f = ALDKRLS_AKB_2(sigma=sigma, epsilon=eps, K_akb=10)
elif kaf == 'QKLMS_AMK':
from KAF import QKLMS_AMK
f = QKLMS_AMK(sigma=sigma, epsilon=eps)
else:
print('Unknown KAF')
return
fig = plt.figure()
ax = fig.add_subplot(111)
y = np.zeros(d.shape)
CB_ant = 0
for n in range(len(u)):
y[n] = f.evaluate(u[n].reshape(1, -1), d[n].reshape(1, -1))[0]
if n > 3:
ax.plot(np.array([n - 1, n]),
d[n - 2:n],
color='blue',
label='Target')
ax.plot(np.array([n - 1, n]),
y[n - 2:n],
color='red',
label='Predicted')
plt.ylim([dmin, dmax])
plt.pause(1e-3)
if CB_ant != len(f.CB):
ax.scatter(n, y[n], color='black', label='CB update', marker='+')
CB_ant = len(f.CB)
plt.show()
return
def __ch_noise_removal(self, noise_true, X_true):
import numpy as np
from KAF import QKLMS_AMK
f = QKLMS_AMK(embedding=int(self.embedding),
eta=self.eta,
epsilon=self.epsilon,
mu=self.mu,
Ka=int(self.Ka))
_, X_em = f.embedder(noise_true, X_true)
if np.sum(noise_true) != 0.0:
noise_pred = f.evaluate(noise_true, X_true)
import matplotlib.pyplot as plt
# # Noise
# plt.figure(figsize=(20,16),dpi=300)
# plt.title("Noise")
# plt.plot(noise_true,label='noise true')
# plt.plot(noise_pred,label='noise predict')
# plt.legend();plt.show()
# # X
# plt.figure(figsize=(20,16),dpi=300)
# plt.title("X")
# plt.plot(X_em,label='x raw')
# plt.plot(X_em.ravel() - noise_pred.ravel(),label='x cleaned')
# plt.legend();plt.show()
# # X
# plt.figure(figsize=(20,16),dpi=300)
# plt.title("X raw adn noise pred")
# plt.plot(X_em,label='x raw')
# plt.plot(noise_pred.ravel(),label='noise')
# plt.legend();plt.show()
# # VS X
# plt.figure(figsize=(20,16),dpi=300)
# plt.title("X vs")
# plt.plot(X_em.ravel(),label='x true')
# plt.plot(noise_pred,label='noise pred')
# plt.plot(X_em.ravel() - noise_pred.ravel(),label='x cleaned')
# plt.legend();plt.show()
return X_em.ravel() - noise_pred.ravel()
else:
return X_em.ravel()
def MC_testingMSE_QKLMS_AMK(dataset,eta,epsilon,mu,K,trainSetSize,testSetSize, MonteCarlo_N):
Mc_MSE = []
samples = trainSetSize*2
from tqdm import tqdm
from KAF import QKLMS_AMK
import numpy as np
for rep in tqdm(range(MonteCarlo_N)):
#train set
if dataset == 'lorenz' or dataset == "chua":
var = 0.1
u,d = db(samples=samples, system=dataset)
noise = np.sqrt(var)*np.random.randn(trainSetSize).reshape(-1,1)
u_train = u[:trainSetSize] + noise
d_train = d[:trainSetSize] + noise
# test set
u,d = db(samples=samples, system=dataset)
noise = np.sqrt(var)*np.random.randn(testSetSize).reshape(-1,1)
u_test = u[:testSetSize] + noise
d_test = d[:testSetSize] + noise
elif dataset == "4.2":
u,d = db2(samples=samples)
u_train = u[:trainSetSize]
d_train = d[:trainSetSize]
# test set
u,d = db2(samples=samples)
u_test = u[:testSetSize]
d_test = d[:testSetSize]
mse = []
i=0 # for option 2
f = QKLMS_AMK(eta,epsilon,mu=mu,Ka=K,A_init="pca")
f.evaluate(u[:100],d[:100])
for ui,di in tqdm(zip(u_train,d_train)):
try:
f.evaluate(ui,di)
# Option 1
# y_pred = f.predict(u_test)
# mse.append(np.mean((d_test-np.array(y_pred).reshape(-1,1))**2/d_test**2))
# Option 2
if np.mod(i,5)==0:
y_pred = f.predict(u_test)
mse.append(np.sum((d_test-np.array(y_pred).reshape(-1,1))**2)/np.sum(d_test**2))
except:
mse.append(0)
i+=1
Mc_MSE.append(mse)
return np.mean(np.array(Mc_MSE),axis=0).reshape(-1,1)
def singleChannelNoiseRemoval(self, X, r):
import numpy as np
from KAF import QKLMS_AMK
f = QKLMS_AMK(embedding=int(self.embedding), eta=self.eta, epsilon=self.epsilon, mu=self.mu, Ka=int(self.Ka))
_,X_ = f.embedder(r,X)
if np.sum(r) != 0.0:
f.evaluate(r[:100],X[:100]) # Evaluation for PCA initialization
v = np.array(f.evaluate(r,X))
return X_.ravel() - v.ravel()
else:
return X_.ravel()
for param in tqdm(param_list):
fold = 0
kf = KFold(n_splits=folds)
r2_temporal = []
params_results = param.copy()
for train_index, test_index in kf.split(Xdata, labels):
print("\n###########################################")
print("\nFILE : ", filename)
print("\nFOLD: ", fold)
#print("TRAIN:", train_index, "TEST:", test_index)
X_train, X_test = Xdata[test_index], Xdata[train_index]
N_train, N_test = Noise[test_index], Noise[train_index]
y_train, y_test = labels[test_index], labels[train_index]
f = QKLMS_AMK()
f.set_params(**param)
r2 = []
N_train_t = N_train.reshape(-1, N_train.shape[2])
ind = np.random.permutation(len(N_train_t))[:20]
for channel in tqdm(N_train_t[ind]):
try:
pred = np.array(f.evaluate(channel, channel)).reshape(-1, 1)
_, target = f.embedder(channel, channel)
r2.append(r2_score(target, pred))
#plt.scatter(target,pred)
#plt.show()