def test_centered_difference_length(): x = 2 * np.linspace(1, 100, 100) centered_difference = FiniteDifference(order=2) assert len(centered_difference(x)) == len(x) centered_difference_nans = FiniteDifference(order=2, drop_endpoints=True) assert len(centered_difference_nans(x)) == len(x)
def test_forward_difference_length(): x = 2 * np.linspace(1, 100, 100) forward_difference = FiniteDifference(order=1) assert len(forward_difference(x)) == len(x) forward_difference_nans = FiniteDifference(order=1, drop_endpoints=True) assert len(forward_difference_nans(x)) == len(x)
def __init__( self, optimizer=None, feature_library=None, differentiation_method=None, feature_names=None, t_default=1, discrete_time=False, n_jobs=1, ): if optimizer is None: optimizer = STLSQ() self.optimizer = optimizer if feature_library is None: feature_library = PolynomialLibrary() self.feature_library = feature_library if differentiation_method is None: differentiation_method = FiniteDifference() self.differentiation_method = differentiation_method if not isinstance(t_default, float) and not isinstance(t_default, int): raise ValueError("t_default must be a positive number") elif t_default <= 0: raise ValueError("t_default must be a positive number") else: self.t_default = t_default self.feature_names = feature_names self.discrete_time = discrete_time self.n_jobs = n_jobs
def __init__( self, optimizer=STLSQ(), feature_library=PolynomialFeatures(), differentiation_method=FiniteDifference(), feature_names=None, discrete_time=False, n_jobs=1, ): self.optimizer = optimizer self.feature_library = feature_library self.differentiation_method = differentiation_method self.feature_names = feature_names self.discrete_time = discrete_time self.n_jobs = n_jobs
def data_linear_oscillator_corrupted(): t = np.linspace(0, 1, 100) x = 3 * np.exp(-2 * t) y = 0.5 * np.exp(t) np.random.seed(1) corrupt_idxs = np.random.choice(np.arange(1, t.size - 1), t.size // 20) x[corrupt_idxs] = 0 X = np.stack((x, y), axis=-1) X_dot = FiniteDifference(order=2)(X, t) # build an array of the indices of samples that should be trimmed trimmed_idxs = np.concatenate( (corrupt_idxs - 1, corrupt_idxs, corrupt_idxs + 1)) trimming_array = np.ones(X.shape[0]) trimming_array[trimmed_idxs] = 0.0 return X, X_dot, trimming_array
def __init__( self, n_forcing_params, forcing_functions, feature_library=PolynomialFeatures(), differentiation_method=FiniteDifference(), feature_names=None, discrete_time=False, n_jobs=1, **optimizer_kws, ): optimizer = SR3Forcing(n_forcing_params, forcing_functions, **optimizer_kws) super(SINDyForcing, self).__init__( optimizer=optimizer, feature_library=feature_library, differentiation_method=differentiation_method, feature_names=feature_names, discrete_time=discrete_time, n_jobs=n_jobs, )
def test_centered_difference(data): x, x_dot = data centered_difference = FiniteDifference(order=2) np.testing.assert_allclose(centered_difference(x), x_dot)
def test_centered_difference_2d(data_derivative_2d): x, x_dot = data_derivative_2d centered_difference = FiniteDifference(order=2) np.testing.assert_allclose(centered_difference(x), x_dot)
def test_forward_difference(data): x, x_dot = data forward_difference = FiniteDifference(order=1) np.testing.assert_allclose(forward_difference(x), x_dot)
def test_centered_difference_variable_timestep_length(): t = np.linspace(1, 10, 100) ** 2 x = 2 * t centered_difference = FiniteDifference(order=2) assert len(centered_difference(x, t) == len(x))
def test_forward_difference_2d(data_derivative_2d): x, x_dot = data_derivative_2d forward_difference = FiniteDifference(order=1) np.testing.assert_allclose(forward_difference(x), x_dot)
def test_forward_difference_variable_timestep_length(): t = np.linspace(1, 10, 100) ** 2 x = 2 * t forward_difference = FiniteDifference(order=1) assert len(forward_difference(x, t) == len(x))
def test_finite_difference(data, order): x, x_dot = data method = FiniteDifference(order=order) np.testing.assert_allclose(method(x), x_dot)
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
def test_order_error(): with pytest.raises(NotImplementedError): FiniteDifference(order=3) with pytest.raises(ValueError): FiniteDifference(order=-1)
def test_centered_difference_dim(): x = np.ones((5, 5, 5)) centered_difference = FiniteDifference(order=2) with pytest.raises(ValueError): centered_difference(x)
def test_forward_difference_dim(): x = np.ones((5, 5, 5)) forward_difference = FiniteDifference(order=1) with pytest.raises(ValueError): forward_difference(x)
def test_nan_derivatives(data_lorenz): x, t = data_lorenz model = SINDy(differentiation_method=FiniteDifference(drop_endpoints=True)) model.fit(x, t) check_is_fitted(model)