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.]))