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