Functional tests + workflow

.github/workflows/discovery.yml

@@ -0,0 +1,46 @@
+name: EPDE Discovery (slow) tests
+
+on:
+  workflow_dispatch:
+
+jobs:
+  discovery:
+    runs-on: ubuntu-latest
+    timeout-minutes: 360
+
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11"]
+        operator: ["DeepXDEBasedFitness", "PIC", "L2LRFitness"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install torch
+          echo "PYTHONPATH=$PYTHONPATH:$(pwd)" >> $GITHUB_ENV
+
+      - name: Run discovery tests
+        run: |
+          pytest tests/functional/ -m functional \
+            --discovery --report \
+            --operators ${{ matrix.operator }} \
+            --ignore=tests/functional/tests/test_ns.py \
+            --timeout=3600
+
+      - name: Upload reports
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: reports-${{ matrix.operator }}
+          path: reports/

.github/workflows/test-functional.yml

@@ -0,0 +1,47 @@
+name: EPDE Core Tests
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    name: pytest (${{ matrix.python-version }}) / ${{ matrix.split }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11"]
+        operator: ["L2LRFitness"]
+        split: [1, 2, 3, 4]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install torch
+          pip install pytest-xdist pytest-split pytest-timeout
+          echo "PYTHONPATH=$PYTHONPATH:$(pwd)" >> $GITHUB_ENV
+
+      - name: Run split tests
+        run: |
+          pytest tests/functional/ \
+            --splits 4 --group ${{ matrix.split }} \
+            --durations=20 \
+            --timeout=600 \
+            -m "not slow" \
+            --operators ${{ matrix.operator }}

.gitignore

@@ -50,6 +50,7 @@ coverage.xml
 *.py,cover
 .hypothesis/
 .pytest_cache/
+reports/
 
 # Translations
 *.mo

epde/integrate/deepxde_integration.py

@@ -9,6 +9,8 @@
 import deepxde as dde
 from abc import ABC, abstractmethod
 
+os.makedirs(os.path.expanduser('~/.deepxde'), exist_ok=True)
+
 class SolverStrategy(ABC):
     @abstractmethod
     def solve(self, eq_list: List[Equation], var_names: List[str],

epde/operators/utils/parameters/default_parameters_multi_objective.json

@@ -30,10 +30,20 @@
         "penalty_coeff" : 0.2,
         "pinn_loss_mult" : 1e4
  	},
-	"DeepXDEBasedFitness" : {
-        "penalty_coeff" : 0.2,
-        "pinn_loss_mult" : 1e4
- 	},
+	"DeepXDEBasedFitness": {
+        "deepxde_config": {
+            "net": [95, 100, 95],
+            "activation": "tanh",
+            "optimizer": "adam",
+            "lr": 1e-3,
+            "num_domain": 1000,
+            "num_boundary": 200,
+            "num_initial": 200,
+            "epochs": 2000
+        },
+        "penalty_coeff": 0.2,
+        "error_metric": "rmse"
+    },
  	"ParetoLevelsCrossover" : {
 
  	},

projects/pic/data/ac/ac.py

@@ -78,15 +78,13 @@ def prepare_suboperators(fitness_operator: CompoundOperator, operator_params: di
     sparsity = LASSOSparsity()
     coeff_calc = LinRegBasedCoeffsEquation()
 
-    # sparsity = map_operator_between_levels(sparsity, 'gene level', 'chromosome level')
-    # coeff_calc = map_operator_between_levels(coeff_calc, 'gene level', 'chromosome level')
-
-    fitness_operator.set_suboperators({'sparsity': sparsity,
-                                       'coeff_calc': coeff_calc})
-    fitness_cond = lambda x: not getattr(x, 'fitness_calculated')
+    fitness_operator.set_suboperators({'sparsity': sparsity, 'coeff_calc': coeff_calc})
     fitness_operator.params = operator_params
-    fitness_operator = map_operator_between_levels(fitness_operator, 'gene level', 'chromosome level',
-                                                   objective_condition=fitness_cond)
+
+    if 'chromosome level' not in fitness_operator._tags:
+        fitness_cond = lambda x: not getattr(x, 'fitness_calculated')
+        fitness_operator = map_operator_between_levels(fitness_operator, 'gene level', 'chromosome level',
+                                                       objective_condition=fitness_cond)
     return fitness_operator
 
 def ac_data(filename: str):
@@ -98,6 +96,14 @@ def ac_data(filename: str):
     return grids, data
 
 
+def get_pic_network_summary(operator):
+    if operator.adapter is None or operator.adapter.net is None:
+        return None
+    net = operator.adapter.net
+    total_params = sum(p.numel() for p in net.parameters())
+    layers = [str(layer) for layer in net.layers] if hasattr(net, 'layers') else []
+    return {'total_parameters': total_params, 'layers': layers}
+
 def AC_test(operator: CompoundOperator, foldername: str, noise_level: int = 0):
     # Test scenario to evaluate performance on Allen-Cahn equation
     eq_ac_symbolic = '0.0001 * d^2u/dx1^2{power: 1.0} + -5.0 * u{power: 3.0} + 5.0 * u{power: 1.0} + 0.0 = du/dx0{power: 1.0}'
@@ -172,40 +178,45 @@ def ac_discovery(foldername, noise_level):
 if __name__ == "__main__":
     import torch
     from epde.operators.utils.default_parameter_loader import EvolutionaryParams
+    global_var.solution_guess_nn = None
     print(torch.cuda.is_available())
     print(f"CUDA version linked with PyTorch: {torch.version.cuda}")
     # Operator = fitness.SolverBasedFitness # Replace by the developed PIC-based operator.
-    # Operator = fitness.PIC
-    #Operator = fitness.L2LRFitness
-    Operator = fitness.DeepXDEBasedFitness
+    #Operator = fitness.PIC
+    Operator = fitness.L2LRFitness
+    #Operator = fitness.DeepXDEBasedFitness
     params = EvolutionaryParams()
-    #operator_params = params.get_default_params_for_operator('DiscrepancyBasedFitnessWithCV') #{"penalty_coeff": 0.2, "pinn_loss_mult": 1e4}
-    try:
-        operator_params = params.get_default_params_for_operator('DeepXDEBasedFitness')
-    except Exception as e:
-        print(f"Предупреждение: не удалось загрузить параметры для DeepXDEBasedFitness: {e}")
-        print("Использую ручную конфигурацию.")
-        operator_params = {
-            "deepxde_config": {
-                "net": [50, 50, 50],
-                "activation": "tanh",
-                "optimizer": "adam",
-                "lr": 1e-3,
-                "num_domain": 1000,
-                "num_boundary": 200,
-                "num_initial": 200,
-                "iterations": 2
-            },
-            "penalty_coeff": 0.2,
-            "error_metric": "rmse"
-        }
+    operator_params = params.get_default_params_for_operator('DiscrepancyBasedFitnessWithCV') #{"penalty_coeff": 0.2, "pinn_loss_mult": 1e4}
+    #operator_params = params.get_default_params_for_operator('PIC')
+
+    # try:
+    #     operator_params = params.get_default_params_for_operator('DeepXDEBasedFitness')
+    # except Exception as e:
+    #     print(f"Предупреждение: не удалось загрузить параметры для DeepXDEBasedFitness: {e}")
+    #     print("Использую ручную конфигурацию.")
+    #     operator_params = {
+    #         "deepxde_config": {
+    #             "net": [50, 50, 50],
+    #             "activation": "tanh",
+    #             "optimizer": "adam",
+    #             "lr": 1e-3,
+    #             "num_domain": 1000,
+    #             "num_boundary": 200,
+    #             "num_initial": 200,
+    #             "iterations": 2
+    #         },
+    #         "penalty_coeff": 0.2,
+    #         "error_metric": "rmse"
+    #     }
 
     print('operator_params ', operator_params)
+
     fit_operator = prepare_suboperators(Operator(list(operator_params.keys())), operator_params)
+    #get_pic_network_summary(fit_operator)
 
     # Paths
     directory = os.path.dirname(os.path.realpath(__file__))
     ac_folder_name = os.path.join(directory)
 
-    #AC_test(fit_operator, ac_folder_name, 0)
-    ac_discovery(ac_folder_name, 0)
+    AC_test(fit_operator, ac_folder_name, 0)
+    # ac_discovery(ac_folder_name, 0)

projects/pic/data/burgers/burgers.py

@@ -49,13 +49,19 @@ def compare_equations(correct_symbolic: str, eq_incorrect_symbolic: str,
     for var in all_vars:
         correct_eq.vals[var].main_var_to_explain = var
         correct_eq.vals[var].metaparameters = metaparams
+        correct_eq.vals[var].weights_internal = np.ones(len(correct_eq.vals[var].structure) - 1)
+        correct_eq.vals[var].weights_internal_evald = True
+        correct_eq.vals[var].weights_final_evald = True
     print(correct_eq.text_form)
 
     incorrect_eq = translate_equation(eq_incorrect_symbolic, search_obj.pool,
                                       all_vars=all_vars)  # , all_vars = ['u', 'v'])
     for var in all_vars:
         incorrect_eq.vals[var].main_var_to_explain = var
         incorrect_eq.vals[var].metaparameters = metaparams
+        incorrect_eq.vals[var].weights_internal = np.ones(len(incorrect_eq.vals[var].structure) - 1)
+        incorrect_eq.vals[var].weights_internal_evald = True
+        incorrect_eq.vals[var].weights_final_evald = True
     print(incorrect_eq.text_form)
 
     fit_operator.apply(correct_eq, {})
@@ -109,8 +115,8 @@ def burgers_data(filename: str):
 
 def burgers_sindy_test(operator: CompoundOperator, foldername: str, noise_level: int = 0):
     # Test scenario to evaluate performance on Allen-Cahn equation
-    eq_burgers_symbolic = '0.0001 * d^2u/dx1^2{power: 1.0} + -5.0 * u{power: 3.0} + 5.0 * u{power: 1.0} + 0.0 = du/dx0{power: 1.0}'
-    eq_burgers_incorrect = '-1.0 * d^2u/dx0^2{power: 1.0} + 1.5 * u{power: 1.0} + -0.0 = du/dx0{power: 1.0}'
+    eq_burgers_symbolic = '-1.0 * u{power: 1.0} * du/dx1{power: 1.0} + 0.01 * d^2u/dx1^2{power: 1.0} + 0.0 = du/dx0{power: 1.0}'
+    eq_burgers_incorrect = '0.02 * d^2u/dx1^2{power: 1.0} + -0.98 * u{power: 1.0} * du/dx1{power: 1.0} + 0.0 * u{power: 1.0} + 0.0 = du/dx0{power: 1.0}'
 
     grid, data = burgers_sindy_data(os.path.join(foldername, 'burgers.mat'))
     noised_data = noise_data(data, noise_level)
@@ -240,6 +246,6 @@ def burgers_sindy_discovery(foldername, noise_level):
     directory = os.path.dirname(os.path.realpath(__file__))
     burgers_folder_name = os.path.join(directory)
 
-    burgers_discovery(burgers_folder_name, 0)
+    # burgers_discovery(burgers_folder_name, 0)
     # burgers_sindy_test(fit_operator, burgers_folder_name, 0)
-    # burgers_sindy_discovery(burgers_folder_name, 0)
+    burgers_sindy_discovery(burgers_folder_name, 0)