{ "cells": [ { "cell_type": "markdown", "id": "a9aef486-0d8b-47d1-aee0-d1c6b1d08836", "metadata": {}, "source": [ "# Discovering the Poisson Equation with SR-DEC" ] }, { "cell_type": "markdown", "id": "54ab6e6b-5cb6-41ac-9a0a-5616db5f003d", "metadata": {}, "source": [ "In this tutorial, we are going to see how to discover the **1D Poisson equation** using `flex` and **SR-DEC**, a new symbolic regression strategy developed in the paper [Discovering interpretable physical models using symbolic regression and discrete exterior calculus\n", "](https://iopscience.iop.org/article/10.1088/2632-2153/ad1af2/meta). \n", "The 1D Poisson equation is a second-order elliptic partial differential equation that models steady-state diffusion processes such as heat conduction, electrostatics, and gravitational potential in one spatial dimension. It is typically written as \n", "$$\\frac{d^2 u(x)}{dx^2} + f(x) = 0, \\quad x \\in (a,b),$$\n", "where $u(x)$is the unknown scalar field and $f(x)$ is a given source term. To obtain a unique solution, the equation must be complemented with appropriate boundary conditions, such as Dirichlet conditions at $x=a$ and $x=b$. \n", "The 1D Poisson equation admits a natural **variational (weak) formulation**, that is, under mild assumptions on $f$, finding the solution of the Poisson equation is equivalent on minimizing the Dirichlet functional\n", "$$\\mathcal{F}(u) := \\frac{1}{2}\\int_a^b (u'(x))^2\\,dx - \\int_a^b f(x)\\,u(x)\\,dx$$\n", "under some Dirichlet boundary conditions.\n", "The mathematical language used to discretize the variational and non-variational formulation of the Poisson equation is **Discrete Exterior Calculus**. The (discrete) Poisson equation is then written as\n", "$$\\delta d u + f = 0 \\quad \\text{or equivalently} \\quad \\star d \\star d u + f = 0,$$\n", "and its variational formulation becomes\n", "$$\\mathcal{F}(u) := \\frac{1}{2}\\langle du, du \\rangle - \\langle u, f \\rangle = \\frac{1}{2}\\langle \\delta du, u \\rangle - \\langle u, f \\rangle.$$\n", "\n", "For the non-variational formulation, the SR strategy discovers the LHS of the equation, while in the variational case the goal is finding the Dirichlet functional. The DEC language is handled by [`dctkit`](https://github.com/cpml-au/dctkit). " ] }, { "cell_type": "markdown", "id": "76dea310-9701-4670-ba22-38b9b5705e76", "metadata": {}, "source": [ "## Imports and dependencies\n", "\n", "Main components:\n", "- `dctkit`: used for mesh generation, cochains, and discrete differential operators.\n", "- `ray`: enables parallel execution of genetic programming runs.\n", "- `numpy`: numerical array handling." ] }, { "cell_type": "code", "execution_count": 1, "id": "9c0f7ac3-51e8-4940-941f-acf70df431f7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "env: RAY_ACCEL_ENV_VAR_OVERRIDE_ON_ZERO=0\n" ] } ], "source": [ "%env RAY_ACCEL_ENV_VAR_OVERRIDE_ON_ZERO=0" ] }, { "cell_type": "code", "execution_count": 2, "id": "5ba1ffa4", "metadata": {}, "outputs": [], "source": [ "from dctkit.dec import cochain as C\n", "from dctkit.mesh.simplex import SimplicialComplex\n", "from dctkit.mesh.util import generate_line_mesh, build_complex_from_mesh\n", "from dctkit.math.opt import optctrl as oc\n", "from deap import gp\n", "from flex.gp import regressor as gps\n", "from flex.gp.util import compile_individuals\n", "from dctkit import config\n", "import dctkit\n", "import numpy as np\n", "import jax.numpy as jnp\n", "import ray\n", "import math\n", "from typing import Tuple, Callable, List\n", "import os\n", "from flex.gp.util import load_config_data\n", "from flex.gp.primitives import add_primitives_to_pset_from_dict\n", "\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 3, "id": "902c2920", "metadata": {}, "outputs": [], "source": [ "# choose precision and whether to use GPU or CPU\n", "# needed for context of the plots at the end of the evolution\n", "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n", "config()" ] }, { "cell_type": "markdown", "id": "8148bee8", "metadata": {}, "source": [ "## Evaluation metric\n", "\n", "Let $\\Omega$ be the domain where the Poisson equation is defined. To evaluate each individual, we numerically compute the solution by solving the following optimization problem\n", "\n", "$$\\min_{v \\in \\mathbb{R}^n} F_I(v, f)|_{\\Omega} + \\gamma ||v|_{\\partial\\Omega} - u|_{\\partial\\Omega}||^2,$$\n", "\n", "where $F_I(v, f) := ||I(v,f)|_{\\Omega}||^2$ for the non-variational case, otherwise $F_I(v, f) := I(v,f)$. Let $u_I$ be the solution of the optimization problem, then the evaluation metric used is the standard MSE between $u_I$ and the data $u$." ] }, { "cell_type": "code", "execution_count": 4, "id": "b02453d4", "metadata": {}, "outputs": [], "source": [ "def eval_MSE_sol(\n", " individual: Callable, X, y, S: SimplicialComplex, u_0: C.CochainP0, residual_mode: bool =\"True\"\n", ") -> float:\n", "\n", " num_nodes = S.num_nodes\n", "\n", " # need to call config again before using JAX in energy evaluations to make sure that\n", " # the current worker has initialized JAX\n", " os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n", " config()\n", "\n", " if residual_mode:\n", "\n", " # objective: squared norm of the residual of the equation + penalty on Dirichlet\n", " # boundary condition on the first node\n", " def obj(x, y):\n", " penalty = 100./2 * (x[0] ** 2 + (x[-1]-1)**2)\n", " u = C.CochainP0(S, x)\n", " f = C.CochainP0(S, y)\n", " r = individual(u, f).coeffs.flatten()[1:-1]\n", " total_energy = jnp.linalg.norm(r)**2 + penalty\n", " return total_energy\n", " else:\n", " # objective: variational formulation of the equation + penalty on Dirichlet\n", " # boundary condition on the first node\n", " def obj(x, y):\n", " penalty = 100./2 * (x[0] ** 2 + (x[-1]-1)**2)\n", " u = C.CochainP0(S, x)\n", " f = C.CochainP0(S, y)\n", " total_energy = individual(u, f) + penalty\n", " return total_energy\n", "\n", " prb = oc.OptimizationProblem(dim=num_nodes, state_dim=num_nodes, objfun=obj)\n", "\n", " MSE = 0.0\n", "\n", " # set additional arguments of the objective function\n", " # (apart from the vector of unknowns)\n", " args = {\"y\": X}\n", " prb.set_obj_args(args)\n", "\n", " # minimize the objective\n", " u = prb.solve(x0=u_0.coeffs.flatten(), ftol_abs=1e-12, ftol_rel=1e-12, maxeval=1000)\n", "\n", " if y is not None:\n", " if (\n", " prb.last_opt_result == 1\n", " or prb.last_opt_result == 3\n", " or prb.last_opt_result == 4\n", " ):\n", " MSE = np.mean(np.linalg.norm(u - y) ** 2)\n", " else:\n", " MSE = math.nan\n", "\n", " if math.isnan(MSE):\n", " MSE = 1e5\n", "\n", " return MSE, [u]" ] }, { "cell_type": "markdown", "id": "c0c0e4dc", "metadata": {}, "source": [ "## Fitness, predict and score functions" ] }, { "cell_type": "code", "execution_count": 5, "id": "6d33cf37", "metadata": {}, "outputs": [], "source": [ "def get_features_batch(individ_feature_extractors, individuals_str_batch):\n", " features_batch = [\n", " [fe(i) for i in individuals_str_batch] for fe in individ_feature_extractors\n", " ]\n", "\n", " indlen = features_batch[0]\n", " return indlen\n", "\n", "def fitness(\n", " individuals_str: list[str],\n", " toolbox,\n", " X,\n", " y,\n", " S: SimplicialComplex,\n", " u_0: C.CochainP0,\n", " residual_mode: bool,\n", " penalty: dict,\n", ") -> Tuple[float,]:\n", "\n", " callables = compile_individuals(toolbox, individuals_str)\n", " indlen = get_features_batch([len], individuals_str)\n", "\n", " fitnesses = [None] * len(individuals_str)\n", " for i, ind in enumerate(callables):\n", " MSE, _ = eval_MSE_sol(ind, X, y, S, u_0, residual_mode)\n", "\n", " # add penalty on length of the tree to promote simpler solutions\n", " fitnesses[i] = (MSE + penalty[\"reg_param\"] * indlen[i],)\n", "\n", " return fitnesses\n", "\n", "\n", "def predict(\n", " individuals_str: list[str],\n", " toolbox,\n", " X,\n", " S: SimplicialComplex,\n", " u_0: C.CochainP0,\n", " residual_mode: bool,\n", " penalty: dict,\n", ") -> List:\n", "\n", " callables = compile_individuals(toolbox, individuals_str)\n", "\n", " u = [None] * len(individuals_str)\n", "\n", " for i, ind in enumerate(callables):\n", " _, u[i] = eval_MSE_sol(ind, X, None, S, u_0, residual_mode)\n", "\n", " return u\n", "\n", "\n", "def score(\n", " individuals_str: list[str],\n", " toolbox,\n", " X,\n", " y,\n", " S: SimplicialComplex,\n", " u_0: C.CochainP0,\n", " residual_mode: bool,\n", " penalty: dict,\n", ") -> List:\n", "\n", " callables = compile_individuals(toolbox, individuals_str)\n", "\n", " MSE = [None] * len(individuals_str)\n", "\n", " for i, ind in enumerate(callables):\n", " MSE[i], _ = eval_MSE_sol(ind, X, y, S, u_0, residual_mode)\n", "\n", " return MSE" ] }, { "cell_type": "markdown", "id": "dada366a-b88f-49ae-8e33-2ae21d687115", "metadata": {}, "source": [ "## Training Pipeline\n", "\n", "We consider a **1D spatial domain** discretized using a simplicial complex. \n", "The mesh is generated as a line mesh and then converted into a `SimplicialComplex` object, which is required by the DEC framework.\n", "\n", "To validate the symbolic regression pipeline, we generate data from an exact solution, that is:\n", "$$u(x) := x^2.$$\n", "This function is sampled on the mesh vertices and stored as a primal 0-cochain.\n", "Using a known analytical solution allows us to:\n", "- compute the exact forcing term,\n", "- assess whether the learned symbolic model recovers the correct operator." ] }, { "cell_type": "code", "execution_count": 6, "id": "fb12bcd5", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2026-02-10 11:30:36,717\tINFO worker.py:1998 -- Started a local Ray instance. View the dashboard at \u001b[1m\u001b[32mhttp://127.0.0.1:8265 \u001b[39m\u001b[22m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Generating initial population(s)...\n", " Removing duplicates from initial population(s)...\n", " DONE.\n", "DONE.\n", "Evaluating initial population(s)...\n", "DONE.\n", " -= START OF EVOLUTION =- \n", " \t \t fitness \t size \n", " \t \t------------------------------\t------------------------------\n", "gen\tevals\tmin \tavg \tmax \tstd \tmin\tavg \tmax\tstd \n", "1 \t20 \t1.8333\t7.5254\t26.8333\t9.6545\t3 \t8.15\t19 \t4.0407\n", "Best individuals of this generation:\n", "SubCP0(f, f)\n", "2 \t20 \t1.8333\t2.1762\t2.9333 \t0.3111\t3 \t6.35\t14 \t2.9711\n", "Best individuals of this generation:\n", "SubCP0(f, f)\n", "3 \t20 \t1.8332\t1.9033\t2.0333 \t0.0954\t3 \t3.8 \t5 \t0.9798\n", "Best individuals of this generation:\n", "SubCP0(delP1(cobP0(u)), f)\n", "4 \t20 \t1.8332\t1.8333\t1.8333 \t0 \t3 \t3.1 \t5 \t0.4359\n", "Best individuals of this generation:\n", "SubCP0(delP1(cobP0(u)), f)\n", "5 \t20 \t1.6399\t1.814 \t1.8333 \t0.0578\t3 \t3.9 \t13 \t2.3216\n", "Best individuals of this generation:\n", "SubCP0(delP1(cobP0(u)), AddCP0(u, SubCP0(AddCP0(u, u), SubCP0(f, u))))\n", "6 \t20 \t1.5137\t1.7788\t1.8333 \t0.0977\t3 \t4.9 \t13 \t3.1922\n", "Best individuals of this generation:\n", "SubCP0(delP1(cobP0(AddCP0(u, u))), SubCP0(f, u))\n", "7 \t20 \t0.7063\t1.6776\t1.8333 \t0.2499\t3 \t6.7 \t13 \t3.1796\n", "Best individuals of this generation:\n", "AddCP0(AddCP0(f, u), delP1(cobP0(u)))\n", "8 \t20 \t0.7063\t1.4366\t1.6417 \t0.3383\t7 \t9.1 \t13 \t2.6439\n", "Best individuals of this generation:\n", "AddCP0(AddCP0(f, u), delP1(cobP0(u)))\n", "9 \t20 \t0.7063\t1.2616\t1.6417 \t0.3852\t7 \t9.5 \t13 \t2.4393\n", "Best individuals of this generation:\n", "AddCP0(AddCP0(f, u), delP1(cobP0(u)))\n", "10 \t20 \t0.5 \t0.9759\t1.5137 \t0.3251\t5 \t7.9 \t13 \t1.6093\n", "Best individuals of this generation:\n", "AddCP0(f, delP1(cobP0(u)))\n", " -= END OF EVOLUTION =- \n", "The best individual is AddCP0(f, delP1(cobP0(u)))\n", "The best fitness on the training set is 0.5\n", "String of the best individual saved to disk.\n", "Training fitness history saved to disk.\n", "Best individual solution evaluated over the test set saved to disk.\n" ] } ], "source": [ "filename = \"sr_dec.yaml\"\n", "residual_mode = True\n", "\n", "regressor_params, config_file_data = load_config_data(filename)\n", "\n", "# generate mesh and dataset\n", "mesh, _ = generate_line_mesh(num_nodes=11, L=1.0)\n", "S = build_complex_from_mesh(mesh)\n", "S.get_hodge_star()\n", "x = S.node_coords\n", "num_nodes = S.num_nodes\n", "\n", "# generate training and test datasets\n", "# exact solution = x²\n", "u = C.CochainP0(S, np.array(x[:, 0] ** 2, dtype=dctkit.float_dtype))\n", "# compute source term such that u solves the discrete Poisson equation\n", "# Delta u + f = 0, where Delta is the discrete Laplace-de Rham operator\n", "f = C.laplacian(u)\n", "f.coeffs *= -1.0\n", "\n", "X_train = np.array(f.coeffs.ravel(), dtype=dctkit.float_dtype)\n", "y_train = np.array(u.coeffs.ravel(), dtype=dctkit.float_dtype)\n", "\n", "# initial guess for the unknown of the Poisson problem (cochain of nodals values)\n", "u_0_vec = np.zeros(num_nodes, dtype=dctkit.float_dtype)\n", "u_0 = C.CochainP0(S, u_0_vec)\n", "\n", "# define primitive set for the residual of the discrete Poisson equation\n", "if residual_mode:\n", " pset = gp.PrimitiveSetTyped(\"RESIDUAL\", [C.CochainP0, C.CochainP0], C.CochainP0)\n", "else:\n", " pset = gp.PrimitiveSetTyped(\"RESIDUAL\", [C.CochainP0, C.CochainP0], float)\n", "\n", "# rename arguments of the residual\n", "pset.renameArguments(ARG0=\"u\")\n", "pset.renameArguments(ARG1=\"f\")\n", "\n", "pset = add_primitives_to_pset_from_dict(pset, config_file_data[\"gp\"][\"primitives\"])\n", "\n", "penalty = config_file_data[\"gp\"][\"penalty\"]\n", "common_params = {\"S\": S, \"u_0\": u_0, \"penalty\": penalty, \"residual_mode\": residual_mode}\n", "\n", "gpsr = gps.GPSymbolicRegressor(\n", " pset_config=pset,\n", " fitness=fitness,\n", " score_func=score,\n", " predict_func=predict,\n", " print_log=True,\n", " common_data=common_params,\n", " seed_str=None,\n", " save_best_individual=True,\n", " save_train_fit_history=True,\n", " output_path=\"./\",\n", " remove_init_duplicates=True,\n", " **regressor_params\n", ")\n", "\n", "gpsr.fit(X_train, y_train, X_val=X_train, y_val=y_train)\n", "\n", "u_best = gpsr.predict(X_train)\n", "\n", "fit_score = gpsr.score(X_train, y_train)\n", "\n", "gpsr.save_best_test_sols(X_train, \"./\")\n", "\n", "ray.shutdown()" ] }, { "cell_type": "markdown", "id": "73b91e67-7da5-47e4-9643-d6d5ec0f68f9", "metadata": {}, "source": [ "## Plots" ] }, { "cell_type": "code", "execution_count": 7, "id": "5b47fa2a", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(x[:,0], y_train, label=\"Data\")\n", "plt.scatter(x[:,0], u_best, c=\"r\", s=10, label=\"Prediction\")\n", "plt.xlabel(r\"$x$\")\n", "plt.ylabel(r\"$u(x)$\")\n", "plt.grid(True, linestyle=\":\", linewidth=0.5)\n", "plt.legend()\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.0" } }, "nbformat": 4, "nbformat_minor": 5 }