def optimal_NARMA_Comp(test_length=800,
train_length=800,
plot=True,
N=400,
eta=0.4,
gamma=0.05,
tau=400,
bits=np.inf,
preload=True,
write=False,
mask=0.1,
activate='mg',
cv=False,
beta=1.0,
t=1,
k1=1.15,
theta=0.2,
no_act_res=False):
"""
Args:
test_length: length of testing data
train_length: length of training data
N: number of virtual nodes
plot: display calculated time series
gamma: input gain
eta: oscillation strength
bits: bit precision
preload: preload mask and time-series data
mask: amplitude of mask values
activate: activation function to be used (sin**2,tanh,mg)
cv: perform leave-one-out cross validation
beta: driver gain
t: timestep used to solve diffeq,
theta: distance between virtual nodes in time
Returns:
NRMSE: Normalized Root Mean Square Error
"""
# hayes_sol = np.array(1,u.flatten().size())
# hayes_sol = np.array()
# NRMSE_sol_mg = np.array()
activate = ["mg", "hayes"]
for activate in activate:
if activate == "Hayes" and (k1 / eta) < 1:
NRSME = 1
x_test_bot = 0
return NRSME, x_test_bot # Should the parameters be those that put Hayes in unstable territory,
if activate == "hayes":
N = 400
tau = 400
eta = 0.401
gamma = 0.531
theta = 0.2
beta = 0.7
if activate == "mg":
N = 509
tau = 509
eta = 0.94
gamma = 0.28
theta = 0.834
beta = 0.74
# Import u, m, and target
u, m, target = load_NARMA(preload, train_length, test_length, mask, N)
# Instantiate Reservoir, feed in training and predictiondatasets
r1 = mod_Delay_Res(N=N,
k1=k1,
eta=eta,
gamma=gamma,
theta=theta,
beta=beta,
tau=tau)
x = r1.calculate(u[:train_length],
m,
bits,
t,
activate,
no_act_res=no_act_res) #[0]
# Is this correct? It looks like x_test and x_test_bot are defined as the same thing
x_test = r1.calculate(u[train_length:],
m,
bits,
t,
activate,
no_act_res=no_act_res
) #[0] # Changed from [1] to [0]
if no_act_res == True:
x_test_bot = r1.calculate(u[train_length:],
m,
bits,
t,
activate,
no_act_res=no_act_res)[1]
# Train using Ridge Regression with hyperparameter tuning
if cv:
NRMSE, y_test, y_input = cross_validate(alphas=np.logspace(
-20, 5, 16),
x=x,
x_test=x_test,
target=target)
else:
clf = Ridge(alpha=0)
clf.fit(x, target[:train_length])
y_test = clf.predict(x_test)
# Calculate NRMSE of prediction data
NRMSE = np.sqrt(
np.mean(np.square(y_test[50:] - target[train_length + 50:])) /
np.var(target[train_length + 50:]))
# Store the NRMSE predictions of mg and hayes
if activate == "mg":
pre_ridge_mg = x.flatten()
NRMSE_sol_mg = y_test.flatten()
if activate == "hayes":
pre_ridge_hayes = x.flatten()
hayes_sol = y_test.flatten()
if not no_act_res:
x_test_bot = 0 # If I don't want to find the x(t)-x(t-tau) term, set flag before plotting
# Plot predicted Time Series
if plot:
plt.figure(1)
plt.plot(target.flatten()[train_length:], label="NRMSE Input Sequence")
plt.plot(NRMSE_sol_mg, label="mackey Glass")
plt.plot(hayes_sol, label="hayes")
plt.title("Post-Ridge Regression mg vs. hayes")
plt.legend()
plt.figure(2)
plt.plot(pre_ridge_mg, label="mackey Glass")
plt.plot(pre_ridge_hayes, label="hayes")
plt.title("Pre-Ridge Regression mg vs. hayes")
plt.legend()
plt.show()
def mod_NARMA_Test(test_length=800,
train_length=800,
plot=True,
N=400,
eta=0.4,
gamma=0.05,
tau=400,
bits=np.inf,
preload=False,
write=False,
mask=0.1,
activate='mg',
cv=False,
beta=1.0,
t=1,
k1=1,
theta=0.2,
no_act_res=False):
"""
Args:
test_length: length of testing data
train_length: length of training data
N: number of virtual nodes
plot: display calculated time series
gamma: input gain
eta: oscillation strength
bits: bit precision
preload: preload mask and time-series data
mask: amplitude of mask values
activate: activation function to be used (sin**2,tanh,mg)
cv: perform leave-one-out cross validation
beta: driver gain
t: timestep used to solve diffeq,
theta: distance between virtual nodes in time
Returns:
NRMSE: Normalized Root Mean Square Error
"""
if activate == "Hayes" and (k1 / eta) < 1:
NRSME = 1
x_test_bot = 0
return NRSME, x_test_bot # Should the parameters be those that put Hayes in unstable territory,
# Import u, m, and target
u, m, target = load_NARMA(preload, train_length, test_length, mask, N)
# Instantiate Reservoir, feed in training and predictiondatasets
r1 = mod_Delay_Res(N=N,
k1=k1,
eta=eta,
gamma=gamma,
theta=theta,
beta=beta,
tau=tau)
x = r1.calculate(u[:train_length],
m,
bits,
t,
activate,
no_act_res=no_act_res) #[0]
# Is this correct? It looks like x_test and x_test_bot are defined as the same thing
x_test = r1.calculate(
u[train_length:], m, bits, t, activate,
no_act_res=no_act_res) #[0] # Changed from [1] to [0]
if no_act_res == True:
x_test_bot = r1.calculate(u[train_length:],
m,
bits,
t,
activate,
no_act_res=no_act_res)[1]
# Train using Ridge Regression with hyperparameter tuning
if cv:
NRMSE, y_test, y_input = cross_validate(alphas=np.logspace(-20, 5, 16),
x=x,
x_test=x_test,
target=target)
else:
clf = Ridge(alpha=0)
clf.fit(x, target[:train_length])
y_test = clf.predict(x_test)
# Calculate NRMSE of prediction data
NRMSE = np.sqrt(
np.mean(np.square(y_test[50:] - target[train_length + 50:])) /
np.var(target[train_length + 50:]))
# Write to File
if write:
write_func(x, x_test)
if not no_act_res:
x_test_bot = 0 # If I don't want to find the x(t)-x(t-tau) term, set flag before plotting
# Plot predicted Time Series
if plot:
plot_func(x, x_test_bot, u, y_test, target, NRMSE, train_length, N)
return NRMSE, x_test_bot, u
def Identical_NARMA_Comp(test_length=800,
train_length=800,
plot=True,
N=400,
eta=0.4,
gamma=0.05,
tau=400,
bits=np.inf,
preload=False,
write=False,
mask=0.1,
activate='mg',
cv=True,
beta=1.0,
t=1,
k1=1.15,
theta=0.2,
no_act_res=False):
"""
Args:
test_length: length of testing data
train_length: length of training data
N: number of virtual nodes
plot: display calculated time series
gamma: input gain
eta: oscillation strength
bits: bit precision
preload: preload mask and time-series data
mask: amplitude of mask values
activate: activation function to be used (sin**2,tanh,mg)
cv: perform leave-one-out cross validation
beta: driver gain
t: timestep used to solve diffeq,
theta: distance between virtual nodes in time
Returns:
NRMSE: Normalized Root Mean Square Error
"""
### Redefine redefine Parameters ###
gamma = 0.5
eta = 0.941
beta = 0.83435
N = 509
tau = 509
theta = 0.20034
# Import u, m, and target
u, m, target = load_NARMA(preload, train_length, test_length, mask, N)
# hayes_sol = np.array(1,u.flatten().size())
# hayes_sol = np.array()
# mg_sol_0 = np.array()
activate_ls = ["mg", "hayes"]
for count, activate in enumerate(activate_ls):
if activate == "Hayes" and (k1 / eta) < 1:
NRSME = 1
x_test_bot = 0
return NRSME, x_test_bot # Should the parameters be those that put Hayes in unstable territory,
# Instantiate Reservoir, feed in training and predictiondatasets
if activate == "mg":
r1 = mod_Delay_Res(N=N,
k1=k1,
eta=eta,
gamma=gamma,
theta=theta,
beta=beta,
tau=tau)
if activate == "hayes":
r1 = hayes_special_Delay_Res(N=N,
k1=k1,
eta=eta,
gamma=gamma,
theta=theta,
beta=beta,
tau=tau)
x = r1.calculate(u[:train_length],
m,
bits,
t,
activate,
no_act_res=no_act_res)
# Is this correct? It looks like x_test and x_test_bot are defined as the same thing
x_test = r1.calculate(
u[train_length:], m, bits, t, activate, no_act_res=no_act_res
) # Don't reference [0] unless no_act_res == True
# Train using Ridge Regression with hyperparameter tuning
if cv:
NRMSE, y_test, y_input = cross_validate(alphas=np.logspace(
-20, 5, 16),
x=x,
x_test=x_test,
target=target)
else:
clf = Ridge(alpha=0)
clf.fit(x, target[:train_length])
y_test = clf.predict(x_test)
# Calculate NRMSE of prediction data
NRMSE = np.sqrt(
np.mean(np.square(y_test[50:] - target[train_length + 50:])) /
np.var(target[train_length + 50:]))
# Store the NRMSE predictions of mg and hayes
if activate == "mg" and count == 0:
mg_x = x
mg_test = x_test
pre_ridge_mg_0 = x.flatten()
np.append(
pre_ridge_mg_0, x_test.flatten()
) # Add on the end the testing pre-ridge data to see if that lines up also
mg_0_NRMSE = NRMSE
mg_sol_0 = y_test.flatten()
if activate == "hayes":
hayes_x = x
hayes_test = x_test
pre_ridge_hayes = x.flatten()
np.append(pre_ridge_hayes, x_test.flatten())
hayes_NRMSE = NRMSE
hayes_sol = y_test.flatten()
if activate == "mg" and count == 1: # This one checks out, regardless of order both mg runs score same NRMSE
pre_ridge_mg_1 = x.flatten()
NRMSE_sol_mg_1 = y_test.flatten()
if not no_act_res:
x_test_bot = 0 # If I don't want to find the x(t)-x(t-tau) term, set flag before plotting
## Let's try to add/subtract the differences between mg (which works) and hayes (which doesn't) and run it back through. Is it just this small difference that's causing the difference in performance?
if 'hayes' in activate_ls:
activate = "hayes"
x_diff = mg_x - hayes_x
x_test_diff = mg_test - hayes_test
# Add the differences to hayes original output
x = hayes_x + x_diff
x_test = hayes_test + x_test_diff
# Calculate and train
# Train using Ridge Regression with hyperparameter tuning
if cv:
NRMSE, y_test, y_input = cross_validate(alphas=np.logspace(
-20, 5, 16),
x=x,
x_test=x_test,
target=target)
else:
clf = Ridge(alpha=0)
clf.fit(x, target[:train_length])
y_test = clf.predict(x_test)
# Calculate NRMSE of prediction data
NRMSE = np.sqrt(
np.mean(np.square(y_test[50:] - target[train_length + 50:])) /
np.var(target[train_length + 50:]))
# Save the resulting NRMSE Values and also the y-solutions of the altered hayes
altered_hayes_NRMSE = NRMSE
altered_hayes_sol = y_test.flatten()
# Plot predicted Time Series
if plot:
if 'hayes' in activate_ls:
plt.figure(1)
plt.plot(target.flatten()[train_length:],
label="NRMSE Input Sequence")
plt.plot(mg_sol_0, label="mackey Glass")
plt.plot(hayes_sol, label="hayes")
plt.title("Post-Ridge Regression mg vs. hayes: NRMSE_h = " +
str(round(hayes_NRMSE, 3)) + ", NRMSE_mg = " +
str(round(mg_0_NRMSE, 3)))
plt.legend()
plt.figure(2)
plt.plot(pre_ridge_mg_0, label="mackey Glass")
plt.plot(pre_ridge_hayes, label="hayes")
plt.title("Pre-Ridge Regression mg vs. hayes")
plt.legend()
plt.figure(3)
plt.plot(altered_hayes_sol, label='altered hayes')
plt.plot(mg_sol_0, label='mackey glass')
plt.title("corrected hayes vs mackey glass: NRMSE_altH = " +
str(altered_hayes_NRMSE) + ", NRMSE_mg = " +
str(mg_0_NRMSE))
plt.legend()
plt.figure(4)
plt.plot(np.append(x_diff.flatten(), x_test_diff.flatten()),
label='mg - hayes')
plt.title("difference between mg and hayes before ridge")
plt.legend()
plt.show()
else:
plt.figure(1)
plt.plot(target.flatten()[train_length:],
label="NRMSE Input Sequence")
plt.plot(mg_sol_0, label="mackey glass 1st pass")
plt.plot(NRMSE_sol_mg_1, label="mackey glass 2nd pass")
plt.title("Post-Ridge Regression mg vs. mg")
plt.legend()
plt.figure(2)
plt.plot(pre_ridge_mg_0, label="mackey glass 1st pass")
plt.plot(pre_ridge_mg_1, label="mackey glass 2nd pass")
plt.title("Pre-Ridge Regression mg vs. mg")
plt.legend()
plt.show()
def NARMA_Test(test_length=800,
train_length=800,
N=400,
eta=0.35,
gamma=0.05,
tau=400,
bits=np.inf,
preload=False,
mask=0.1,
activate='mg',
cv=False,
beta=1.0,
t=1,
theta=0.2,
noise_scale=0.001):
"""
Args:
test_length: length of testing data
train_length: length of training data
num_loops: number of delay loops in reservoir
a: ridge regression parameter
N: number of virtual nodes
plot: display calculated time series
gamma: input gain
eta: oscillation strength
phi: phase of MZN
r: loop delay length
bits: bit precision
preload: preload mask and time-series data
mask: amplitude of mask values
activate: activation function to be used (sin**2,tanh,mg)
cv: perform leave-one-out cross validation
beta: driver gain
V_low: ADC lower bound
V_high: ADC upper bound
t: timestep used to solve diffeq
layers: number of hidden layers, ie number of cascaded reservoirs
sr: splitting ratio
switching: WDM switching
w: number of wavelengths
auto: automatically calculate ADC range
IA: input to all layers of (deep) network
Returns:
NRMSE: Normalized Root Mean Square Error
"""
# Import u and m
if preload:
file1 = open("Data/Input_sequence.txt",
"r") # Reads input and masking files. stores them in u/m
file2 = open("Data/mask_2.txt", "r")
contents = file1.readlines()
contents2 = file2.readlines()
u = []
m = []
for i in range(1000):
u.append(float(contents[i][0:contents[i].find("\t")]))
if i < 400:
m.append(float(contents2[i][0:contents2[i].find("\n")]))
file1.close()
file2.close()
u = np.array(u)
m = np.array(m)
# Randomly initialize u and m
else:
u = np.random.rand(train_length + test_length) / 2.
while NARMA_Diverges(u):
u = np.random.rand(train_length + test_length) / 2.
m = np.array([random.choice([-mask, mask]) for i in range(N)])
# Calculate NARMA10 target
target = NARMA_Generator(len(u), u)
alphas = np.logspace(-20, 5, 16)
# Instantiate Reservoir, feed in training and predictiondatasets
r1 = ModifiedDelayRC(N=N,
eta=eta,
gamma=gamma,
theta=theta,
beta=beta,
tau=tau)
x = r1.calculate(u[:train_length], m, t, activate, noise_scale)
x_test = r1.calculate(u[train_length:], m, t, activate, noise_scale)
# Train using Ridge Regression with hyperparameter tuning
if (cv):
NRMSE, y_test, y_input = cross_validate(alphas, x, x_test, target)
else:
clf = Ridge(alpha=0)
clf.fit(x, target[:train_length])
y_test = clf.predict(x_test)
y_input = clf.predict(x)
# Calculate NRMSE of prediction data
NRMSE = np.sqrt(np.mean(np.square(y_test[50:] - target[train_length + 50:])) / \
np.var(target[train_length + 50:]))
return NRMSE
def NARMA_Test(self,
test_length=500,
train_length=5000,
plot=False,
N=400,
eta=0.4,
gamma=0.05,
tau=400,
fudge=1.0,
preload=False,
write=False,
mask=0.1,
activate='mg',
cv=False,
beta=1.0,
t=1,
theta=0.2,
power=1,
mix_p=0.1):
"""
Args:
test_length: length of testing data
train_length: length of training data
N: number of virtual high_nodes
plot: display calculated time series
gamma: input gain
eta: oscillation strength
bits: bit precision
preload: preload mask and time-series data
mask: amplitude of mask values
activate: activation function to be used (sin**2,tanh,mg)
cv: perform leave-one-out cross validation
beta: driver gain
t: timestep used to solve diffeq,
theta: distance between virtual high_nodes in time
Returns:
NRMSE: Normalized Root Mean Square Error
"""
# Import u, m, and target
u, m, target = load_NARMA(preload, train_length, test_length, mask, N)
# Instantiate Reservoir, feed in training and predictiondatasets
r1 = ModifiedDelayRC(N=N,
eta=eta,
gamma=gamma,
theta=theta,
beta=beta,
tau=tau,
fudge=fudge,
power=power)
x = r1.calculate_mix(u[:train_length], m, t, mix_p)[0]
# Is this correct? It looks like x_test and x_test_bot are defined as the same thing
x_test = r1.calculate_mix(u[train_length:], m, t, mix_p)[0]
# Train using Ridge Regression with hyperparameter tuning
if cv:
alphas = np.logspace(-100, 1, 100)
NRMSE, y_test, y_input1, clf = cross_validate(alphas=alphas,
x=x,
x_test=x_test,
target=target)
else:
clf = Ridge(alpha=0)
# clf1 = LinearRegression(n_jobs=-1)
clf.fit(x, target[:train_length])
y_test = clf.predict(x)
# Calculate NRMSE of prediction data
NRMSE = np.sqrt(
np.mean(np.square(y_test[50:] - target[50:train_length])) /
np.var(target[50:train_length]))
return NRMSE, x, target, x_test, y_test, clf
def NARMA_Test(self, test_length=500, train_length=5000, plot=False, N=400, eta=0.4, gamma=0.05, tau=400, fudge=1.0, preload=False, write=False, mask=0.1, activate='mg', cv=True, beta=1.0, t=1, theta=0.2, power=1): """ Args: test_length: length of testing data train_length: length of training data N: number of virtual high_nodes plot: display calculated time series gamma: input gain eta: oscillation strength bits: bit precision preload: preload mask and time-series data mask: amplitude of mask values activate: activation function to be used (sin**2,tanh,mg) cv: perform leave-one-out cross validation beta: driver gain t: timestep used to solve diffeq, theta: distance between virtual high_nodes in time Returns: NRMSE: Normalized Root Mean Square Error """ # Import u, m, and target u, m, target = load_NARMA(preload, train_length, test_length, mask, N) # Instantiate Reservoir, feed in training and predictiondatasets r1 = ModifiedDelayRC(N=N, eta=eta, gamma=gamma, theta=theta, beta=beta, tau=tau, fudge=fudge, power=power) x1 = r1.calculate(u[:train_length], m, t, 'mg')[0] x2 = r1.calculate(u[:train_length], m, t, 'hayes')[0] # Is this correct? It looks like x_test and x_test_bot are defined as the same thing x_test1 = r1.calculate(u[train_length:], m, t, 'mg')[0] x_test2 = r1.calculate(u[train_length:], m, t, 'hayes')[0] # Train using Ridge Regression with hyperparameter tuning if cv: alphas = np.logspace(-100, 1, 100) NRMSE1, y_test1, y_input1, clf1 = cross_validate(alphas=alphas, x=x1, x_test=x_test1, target=target) # res1 = np.linalg.norm(target[50+train_length:] - y_test1[50:]) ** 2 # ssr = np.sum((target[50+train_length:] - y_test1[50:]) ** 2) # # # total sum of squares # sst = np.sum((target[50+train_length:] - np.mean(target[50+train_length:])) ** 2) # # r2_1 = 1 - (ssr / sst) # NRMSE2, y_test2, y_input2 = cross_validate(alphas=np.logspace(-50, 5, 500), x=x2, x_test=x_test2, # target=target) # res2 = np.linalg.norm(target[50+train_length:] - y_test2[50:]) ** 2 # ssr = np.sum((target[50+train_length:] - y_test2[50:]) ** 2) # # r2_2 = 1 - (ssr / sst) res1 = np.linalg.norm(target[50:train_length] - y_input1[50:]) ** 2 ssr = np.sum((target[50:train_length] - y_input1[50:]) ** 2) # total sum of squares sst = np.sum((target[50:train_length] - np.mean(target[50:train_length])) ** 2) r2_1 = 1 - (ssr / sst) NRMSE2, y_test2, y_input2, clf2 = cross_validate(alphas=alphas, x=x2, x_test=x_test2, target=target) res2 = np.linalg.norm(target[50:train_length] - y_input2[50:]) ** 2 ssr = np.sum((target[50:train_length:] - y_input2[50:]) ** 2) r2_2 = 1 - (ssr / sst) else: clf1 = Ridge(alpha=0) # clf1 = LinearRegression(n_jobs=-1) clf1.fit(x1, target[:train_length]) y_test1 = clf1.predict(x1) # Calculate NRMSE of prediction data NRMSE1 = np.sqrt( np.mean(np.square(y_test1[50:] - target[50:train_length])) / np.var(target[50:train_length])) res1 = np.linalg.norm(target[50:train_length] - y_test1[50:]) ** 2 r2_1 = 0 clf2 = Ridge(alpha=0) # clf2 = LinearRegression(n_jobs=-1) clf2.fit(x2, target[:train_length]) y_test2 = clf2.predict(x2) # Calculate NRMSE of prediction data NRMSE2 = np.sqrt( np.mean(np.square(y_test2[50:] - target[50:train_length])) / np.var(target[50:train_length])) res2 = np.linalg.norm(target[50:train_length] - y_test2[50:]) ** 2 r2_2 = 0 return NRMSE1, NRMSE2, x1, x2, target, x_test1, x_test2, y_test1, y_test2, res1, res2, r2_1, r2_2, clf1, clf2
