def test_trapping_inequality_constraints(thresholds, relax_optim,
noise_levels):
t = np.arange(0, 40, 0.05)
x = odeint(lorenz, [-8, 8, 27], t)
x = x + np.random.normal(0.0, noise_levels, x.shape)
# if order is "feature"
constraint_rhs = np.array([-10.0, -2.0])
constraint_matrix = np.zeros((2, 30))
constraint_matrix[0, 6] = 1.0
constraint_matrix[1, 17] = 1.0
feature_names = ["x", "y", "z"]
opt = TrappingSR3(
threshold=thresholds,
constraint_lhs=constraint_matrix,
constraint_rhs=constraint_rhs,
constraint_order="feature",
inequality_constraints=True,
relax_optim=relax_optim,
)
poly_lib = PolynomialLibrary(degree=2)
model = SINDy(
optimizer=opt,
feature_library=poly_lib,
differentiation_method=FiniteDifference(drop_endpoints=True),
feature_names=feature_names,
)
model.fit(x, t=t[1] - t[0])
assert np.all(
np.dot(constraint_matrix, (model.coefficients()).flatten("F")) <=
constraint_rhs) or np.allclose(
np.dot(constraint_matrix,
(model.coefficients()).flatten("F")), constraint_rhs)
def test_not_fitted(data_1d):
x, t = data_1d
model = SINDy()
with pytest.raises(NotFittedError):
model.predict(x)
with pytest.raises(NotFittedError):
model.get_feature_names()
with pytest.raises(NotFittedError):
model.coefficients()
with pytest.raises(NotFittedError):
model.equations()
with pytest.raises(NotFittedError):
model.simulate(x[0], t)
def test_t_default(data):
x, t, u, _ = data
dt = t[1] - t[0]
model = SINDy()
model.fit(x, u=u, t=dt)
model_t_default = SINDy(t_default=dt)
model_t_default.fit(x, u=u)
np.testing.assert_allclose(model.coefficients(),
model_t_default.coefficients())
np.testing.assert_almost_equal(model.score(x, u=u, t=dt),
model_t_default.score(x, u=u))
def test_model_sindy_equivalence(data_lorenz_c_1d):
x, t, u, _ = data_lorenz_c_1d
model = SINDyEstimator().fit(x, t=t, u=u).fetch_model()
sindy_model = SINDy().fit(x, t=t, u=u)
assert_allclose(model.coefficients(), sindy_model.coefficients())
assert model.n_input_features_ == sindy_model.n_input_features_
assert model.n_output_features_ == sindy_model.n_output_features_
assert model.n_control_features_ == sindy_model.n_control_features_
def test_t_default(data):
x, t = data
dt = t[1] - t[0]
with pytest.raises(ValueError):
model = SINDy(t_default=0)
with pytest.raises(ValueError):
model = SINDy(t_default="1")
model = SINDy()
model.fit(x, dt)
model_t_default = SINDy(t_default=dt)
model_t_default.fit(x)
np.testing.assert_allclose(model.coefficients(), model_t_default.coefficients())
np.testing.assert_almost_equal(model.score(x, t=dt), model_t_default.score(x))
np.testing.assert_almost_equal(
model.differentiate(x, t=dt), model_t_default.differentiate(x)
)
def test_linear_constraints(data_lorenz):
x, t = data_lorenz
library = PolynomialLibrary().fit(x)
constraint_rhs = np.ones(2)
constraint_lhs = np.zeros((2, x.shape[1] * library.n_output_features_))
target_1, target_2 = 1, 3
constraint_lhs[0, 3] = target_1
constraint_lhs[1, library.n_output_features_] = target_2
optimizer = ConstrainedSR3(constraint_lhs=constraint_lhs,
constraint_rhs=constraint_rhs)
model = SINDy(feature_library=library, optimizer=optimizer).fit(x, t)
coeffs = model.coefficients()
np.testing.assert_allclose(np.array([coeffs[0, 3], coeffs[1, 0]]),
np.array([1 / target_1, 1 / target_2]))
def test_coefficients(data_lorenz):
x, t = data_lorenz
model = SINDy()
model.fit(x, t)
c = model.coefficients()
assert np.count_nonzero(c) < 10
def compressible_Framework(inner_prod, time, poly_order, threshold, r, tfac,
SR3Enhanced, make_3Dphaseplots):
"""
Performs the entire vector_POD + SINDy framework for a given polynomial
order and thresholding for the SINDy method.
Parameters
----------
inner_prod: 2D numpy array of floats
(M = number of time samples, M = number of time samples)
The scaled matrix of inner products X*X
time: numpy array of floats
(M = number of time samples)
Time in microseconds
poly_order: int
(1)
Highest polynomial order to use in the SINDy library
threshold: float
(1)
Threshold in the SINDy algorithm, below which coefficients
will be zeroed out.
r: int
(1)
Truncation number of the SVD
tfac: float
(1)
Fraction of the data to treat as training data
SR3Enhanced: SINDy optimizer object
(1)
The SR3 optimizer with linear equality constraints
make_3Dphaseplots: bool
(1)
Flag to make 3D phase plots or not
Returns
-------
t_test: numpy array of floats
(M_test = number of time samples in the test data region)
Time in microseconds in the test data region
x_true: 2D numpy array of floats
(M_test = number of time samples in the test data region,
r = truncation number of the SVD)
The true evolution of the temporal BOD modes
x_sim: 2D numpy array of floats
(M_test = number of time samples in the test data region,
r = truncation number of the SVD)
The model evolution of the temporal BOD modes
S2: 2D numpy array of floats
(M = number of time samples, M = number of time samples)
The singular value matrix
"""
plt.clf()
plt.close('all')
M_train = int(len(time) * tfac)
t_train = time[:M_train]
t_test = time[M_train:]
x, feature_names, S2, Vh, = vector_POD(inner_prod, time, r)
print('Now fitting SINDy model')
if poly_order == 1:
library_functions = [lambda x: x]
library_function_names = [lambda x: x]
if poly_order == 2:
library_functions = [lambda x: x, lambda x, y: x * y, lambda x: x**2]
library_function_names = [
lambda x: x, lambda x, y: x + y, lambda x: x + x
]
if poly_order == 3:
library_functions = [
lambda x: x, lambda x, y: x * y, lambda x: x**2,
lambda x, y, z: x * y * z, lambda x, y: x**2 * y,
lambda x, y: x * y**2, lambda x: x**3
]
library_function_names = [
lambda x: x, lambda x, y: x + y, lambda x: x + x,
lambda x, y, z: x + y + z, lambda x, y: x + x + y,
lambda x, y: x + y + y, lambda x: x + x + x
]
if poly_order == 4:
library_functions = [
lambda x: x, lambda x, y: x * y, lambda x: x**2,
lambda x, y, z: x * y * z, lambda x, y: x**2 * y,
lambda x, y: x * y**2, lambda x: x**3,
lambda x, y, z, w: x * y * z * w, lambda x, y, z: x * y * z**2,
lambda x, y: x**2 * y**2, lambda x, y: x**3 * y, lambda x: x**4
]
library_function_names = [
lambda x: x, lambda x, y: x + y, lambda x: x + x,
lambda x, y, z: x + y + z, lambda x, y: x + x + y,
lambda x, y: x + y + y, lambda x: x + x + x,
lambda x, y, z, w: x + y + z + w, lambda x, y, z: x + y + z + z,
lambda x, y: x + x + y + y, lambda x, y: x + x + x + y,
lambda x: x + x + x + x
]
sindy_library = CustomLibrary(library_functions=library_functions, \
function_names=library_function_names)
constraint_zeros = np.zeros(int(r * (r + 1) / 2))
if poly_order == 1:
constraint_matrix = np.zeros((int(r * (r + 1) / 2), r**2))
for i in range(r):
constraint_matrix[i, i * (r + 1)] = 1.0
q = r
for i in range(r):
counter = 1
for j in range(i + 1, r):
constraint_matrix[q, i * r + j] = 1.0
constraint_matrix[q, i * r + j + counter * (r - 1)] = 1.0
counter = counter + 1
q = q + 1
else:
if poly_order == 2:
#constraint_zeros = np.zeros(6+int(r*(r+1)/2))
#constraint_matrix = np.zeros((6+int(r*(r+1)/2),int(r*(r**2+3*r)/2)))
constraint_matrix = np.zeros(
(int(r * (r + 1) / 2), int(r * (r**2 + 3 * r) / 2)))
if poly_order == 3:
#constraint_matrix = np.zeros((int(r*(r+1)/2),int(r*(r**2+3*r)/2)+336))
constraint_matrix = np.zeros(
(int(r * (r + 1) / 2),
int(r * (r**2 + 3 * r) / 2) + 588)) # 30
if poly_order == 4:
constraint_matrix = np.zeros(
(int(r * (r + 1) / 2), int(r * (r**2 + 3 * r) / 2) + 60))
for i in range(r):
constraint_matrix[i, i * (r + 1)] = 1.0
q = r
for i in range(r):
counter = 1
for j in range(i + 1, r):
constraint_matrix[q, i * r + j] = 1.0
constraint_matrix[q, i * r + j + counter * (r - 1)] = 1.0
counter = counter + 1
q = q + 1
# linear_r4_mat or linear_r12_mat are initial guesses
# for the optimization
linear_r4_mat = np.zeros((r, r))
linear_r4_mat[0, 1] = 0.091
linear_r4_mat[1, 0] = -0.091
linear_r4_mat[2, 3] = 0.182
linear_r4_mat[3, 2] = -0.182
linear_r4_mat[5, 4] = -3 * 0.091
linear_r4_mat[4, 5] = 3 * 0.091
#linear_r4_mat[8,7] = -4*0.091
#linear_r4_mat[7,8] = 4*0.091
#linear_r4_mat[6,7] = 4*0.091
#linear_r4_mat[7,6] = -4*0.091
linear_r12_mat = np.zeros((12, 90))
linear_r12_mat[0, 1] = 0.089
linear_r12_mat[1, 0] = -0.089
linear_r12_mat[2, 3] = 0.172
linear_r12_mat[3, 2] = -0.172
linear_r12_mat[2, 5] = 0.03
linear_r12_mat[5, 2] = -0.03
linear_r12_mat[2, 6] = 0.022
linear_r12_mat[6, 2] = -0.022
linear_r12_mat[6, 4] = 0.022
linear_r12_mat[4, 6] = 0.023
linear_r12_mat[7, 5] = -0.023
linear_r12_mat[5, 7] = -0.123
linear_r12_mat[7, 5] = 0.123
sindy_opt = SR3Enhanced(threshold=threshold, nu=1, max_iter=20000, \
constraint_lhs=constraint_matrix,constraint_rhs=constraint_zeros, \
tol=1e-6,thresholder='l0',initial_guess=linear_r4_mat)
model = SINDy(optimizer=sindy_opt, \
feature_library=sindy_library, \
differentiation_method=FiniteDifference(drop_endpoints=True), \
feature_names=feature_names)
x_train = x[:M_train, :]
x0_train = x[0, :]
x_true = x[M_train:, :]
x0_test = x[M_train, :]
model.fit(x_train, t=t_train, unbias=False)
t_cycle = np.linspace(time[M_train], time[M_train] * 1.3,
int(len(time) / 2.0))
print(model.coefficients())
x_sim,output = model.simulate(x0_test,t_test, \
integrator=odeint,stop_condition=None,full_output=True, \
rtol=1e-20,h0=1e-5) #h0=1e-20
x_sim1,output = model.simulate(-0.4*np.ones(r),t_cycle, \
integrator=odeint,stop_condition=None,full_output=True, \
rtol=1e-20,h0=1e-5)
x_sim2,output = model.simulate(0.15*np.ones(r),t_cycle, \
integrator=odeint,stop_condition=None,full_output=True, \
rtol=1e-20,h0=1e-5)
x_dot = model.differentiate(x, t=time)
x_dot_train = model.predict(x_train)
x_dot_sim = model.predict(x_true)
print('Model score: %f' % model.score(x, t=time))
make_evo_plots(x_dot,x_dot_train, \
x_dot_sim,x_true,x_sim,time,t_train,t_test)
make_table(model, feature_names)
# Makes 3D phase space plots
if make_3Dphaseplots:
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 2)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 3)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 4)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 5)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 6)
make_3d_plots(x_true, x_sim, t_test, 'sim', 3, 4, 5)
make_3d_plots(x_true, x_sim, t_test, 'sim', 4, 5, 6)
make_3d_plots(x_sim1, x_sim2, t_cycle, 'limitcycle')
for i in range(r):
x_sim[:, i] = x_sim[:, i] * sum(np.amax(abs(Vh), axis=1)[0:r])
x_true[:, i] = x_true[:, i] * sum(np.amax(abs(Vh), axis=1)[0:r])
return t_test, x_true, x_sim, S2
