def test_auto_regression_operator_on_ode_with_isolated_perturbations(): set_random_seed(0) diff_eq = LotkaVolterraEquation(2., 1., .8, 1.) cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([1., 2.])) ivp = InitialValueProblem(cp, (0., 10.), ic) oracle = ODEOperator('DOP853', .001) ref_solution = oracle.solve(ivp) ml_op = AutoRegressionOperator(2.5, True) ml_op.train(ivp, oracle, RandomForestRegressor(), 25, lambda t, y: y + np.random.normal(0., .01, size=y.shape), isolate_perturbations=True) ml_solution = ml_op.solve(ivp) assert ml_solution.vertex_oriented assert ml_solution.d_t == 2.5 assert ml_solution.discrete_y().shape == (4, 2) diff = ref_solution.diff([ml_solution]) assert np.all(diff.matching_time_points == np.linspace(2.5, 10., 4)) assert np.max(np.abs(diff.differences[0])) < .01
def test_discrete_initial_condition_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) initial_condition = DiscreteInitialCondition(cp, np.array([10., 100.])) assert np.all(initial_condition.y_0(None) == [10., 100.]) assert np.all(initial_condition.discrete_y_0() == [10., 100.])
def test_solution_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([5., 10.])) ivp = InitialValueProblem(cp, (0., 10.), ic) t_coordinates = np.array([5., 10.]) discrete_y = np.arange(4).reshape((2, 2)) solution = Solution(ivp, t_coordinates, discrete_y) assert solution.initial_value_problem == ivp assert np.array_equal(solution.t_coordinates, t_coordinates) assert np.isclose(solution.d_t, 5.) assert solution.vertex_oriented is None assert np.allclose(solution.y(), [[0., 1.], [2., 3.]]) assert np.allclose(solution.discrete_y(), [[0., 1.], [2., 3.]]) other_solutions = [ Solution(ivp, np.linspace(2.5, 10., 4), np.arange(8).reshape((4, 2))), Solution(ivp, np.linspace(1.25, 10., 8), np.arange(16).reshape((8, 2))) ] expected_differences = [ [[2., 2.], [4., 4.]], [[6., 6.], [12., 12.]], ] diff = solution.diff(other_solutions) assert np.allclose(diff.matching_time_points, [5., 10.]) assert np.allclose(diff.differences, expected_differences)
def test_solution_with_mismatched_discrete_y_shape(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([5., 10.])) ivp = InitialValueProblem(cp, (0., 10.), ic) discrete_y = np.zeros((2, 3)) with pytest.raises(ValueError): Solution(ivp, np.array([5., 10.]), discrete_y)
def test_solution_with_invalid_t_coordinate_dimensions(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([5., 10.])) ivp = InitialValueProblem(cp, (0., 10.), ic) discrete_y = np.zeros((2, 2)) with pytest.raises(ValueError): Solution(ivp, np.array([[5., 10.]]), discrete_y)
def test_ode_operator_on_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) ic = ContinuousInitialCondition(cp, lambda _: np.array([100., 15.])) ivp = InitialValueProblem(cp, (0., 10.), ic) op = ODEOperator('DOP853', 1e-3) solution = op.solve(ivp) assert solution.vertex_oriented is None assert solution.d_t == 1e-3 assert solution.discrete_y().shape == (1e4, 2)
def test_cp_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) assert cp.mesh is None assert cp.static_y_vertex_constraints is None assert cp.static_boundary_vertex_constraints is None assert cp.static_boundary_cell_constraints is None assert cp.static_boundary_constraints(True) is None assert cp.static_boundary_constraints(False) is None assert cp.boundary_conditions is None assert cp.y_shape(True) == cp.y_shape(False) == (diff_eq.y_dimension, ) assert not cp.are_all_boundary_conditions_static assert not cp.are_there_boundary_conditions_on_y
def test_pidon_operator_on_ode_system(): set_random_seed(0) diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) t_interval = (0., .5) sampler = UniformRandomCollocationPointSampler() pidon = PIDONOperator(sampler, .01, True) training_y_0_functions = [ lambda _: np.array([47.5, 25.]), lambda _: np.array([47.5, 27.5]), lambda _: np.array([50., 22.5]), lambda _: np.array([50., 27.5]), lambda _: np.array([52.5, 22.5]), lambda _: np.array([52.5, 25.]), ] test_y_0_functions = [ lambda _: np.array([47.5, 22.5]), lambda _: np.array([50., 25.]), lambda _: np.array([52.5, 27.5]) ] training_loss_history, test_loss_history = pidon.train( cp, t_interval, training_data_args=DataArgs( y_0_functions=training_y_0_functions, n_domain_points=50, n_batches=3 ), test_data_args=DataArgs( y_0_functions=test_y_0_functions, n_domain_points=20, n_batches=1 ), model_args=ModelArgs( latent_output_size=20, branch_hidden_layer_sizes=[20, 20, 20], trunk_hidden_layer_sizes=[20, 20, 20], ), optimization_args=OptimizationArgs( optimizer={ 'class_name': 'Adam', 'config': { 'learning_rate': 1e-4 } }, epochs=3, ic_loss_weight=2., verbose=False ) ) assert len(training_loss_history) == 3 assert len(test_loss_history) == 3 for i in range(2): assert np.sum( training_loss_history[i + 1].weighted_total_loss.numpy()) < \ np.sum(training_loss_history[i].weighted_total_loss.numpy()) assert np.sum(test_loss_history[i + 1].weighted_total_loss.numpy()) < \ np.sum(test_loss_history[i].weighted_total_loss.numpy()) ic = ContinuousInitialCondition(cp, lambda _: np.array([50., 25.])) ivp = InitialValueProblem(cp, t_interval, ic) solution = pidon.solve(ivp) assert solution.d_t == .01 assert solution.discrete_y().shape == (50, 2)
def test_continuous_initial_condition_ode_with_wrong_shape(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) with pytest.raises(ValueError): ContinuousInitialCondition(cp, lambda _: np.array([10., 100., 1.]))
def test_gaussian_initial_condition_ode(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) with pytest.raises(ValueError): GaussianInitialCondition(cp, [(np.array([1.]), np.array([[1.]]))] * 2)
def test_discrete_initial_condition_ode_with_wrong_shape(): diff_eq = LotkaVolterraEquation() cp = ConstrainedProblem(diff_eq) with pytest.raises(ValueError): DiscreteInitialCondition(cp, np.array([10.]))