{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DS4E1PagbDgL"
   },
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tQ1r1bbb0yBv"
   },
   "source": [
    "\n",
    "## Instructions\n",
    "1. Work on a copy of this notebook: _File_ > _Save a copy in Drive_ (you will need a Google account).\n",
    "2. (Optional) If you would like to do the deep learning component of this tutorial, turn on the GPU with Edit->Notebook settings->Hardware accelerator->GPU\n",
    "3. Execute the following cell (click on it and press Ctrl+Enter) to install Julia, IJulia and other packages (if needed, update `JULIA_VERSION` and the other parameters). This takes a couple of minutes.\n",
    "4. Continue to the next section.\n",
    "\n",
    "_Notes_:\n",
    "* If your Colab Runtime gets reset (e.g., due to inactivity), repeat steps 3, 4.\n",
    "* After installation, if you want to change the Julia version or activate/deactivate the GPU, you will need to reset the Runtime: _Runtime_ > _Delete and disconnect runtime_ and repeat steps 2-4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "COndi88gbDgO"
   },
   "source": [
    "**Run the following code to install Julia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GIeFXS0F0zww"
   },
   "outputs": [],
   "source": [
    "%%shell\n",
    "set -e\n",
    "\n",
    "#---------------------------------------------------#\n",
    "JULIA_VERSION=\"1.8.5\"\n",
    "export JULIA_PKG_PRECOMPILE_AUTO=0\n",
    "#---------------------------------------------------#\n",
    "\n",
    "if [ -z `which julia` ]; then\n",
    "  # Install Julia\n",
    "  JULIA_VER=`cut -d '.' -f -2 <<< \"$JULIA_VERSION\"`\n",
    "  echo \"Installing Julia $JULIA_VERSION on the current Colab Runtime...\"\n",
    "  BASE_URL=\"https://julialang-s3.julialang.org/bin/linux/x64\"\n",
    "  URL=\"$BASE_URL/$JULIA_VER/julia-$JULIA_VERSION-linux-x86_64.tar.gz\"\n",
    "  wget -nv $URL -O /tmp/julia.tar.gz # -nv means \"not verbose\"\n",
    "  tar -x -f /tmp/julia.tar.gz -C /usr/local --strip-components 1\n",
    "  rm /tmp/julia.tar.gz\n",
    "\n",
    "  echo \"Installing PyCall.jl...\"\n",
    "  julia -e 'using Pkg; Pkg.add(\"PyCall\"); Pkg.build(\"PyCall\")'\n",
    "  julia -e 'println(\"Success\")'\n",
    "\n",
    "fi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ORv1c6xvbDgV"
   },
   "source": [
    "Install PySR and PyTorch-Lightning:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EhMRSZEYFPLz"
   },
   "outputs": [],
   "source": [
    "%pip install -Uq pysr pytorch_lightning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "etTMEV0wDqld"
   },
   "source": [
    "The following step is not normally required, but colab's printing is non-standard and we need to manually set it up PyJulia:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "j666aOI8xWF_"
   },
   "outputs": [],
   "source": [
    "from julia import Julia\n",
    "\n",
    "julia = Julia(compiled_modules=False, threads=\"auto\")\n",
    "from julia import Main\n",
    "from julia.tools import redirect_output_streams\n",
    "\n",
    "redirect_output_streams()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6u2WhbVhht-G"
   },
   "source": [
    "Let's install the backend of PySR, and all required libraries.\n",
    "\n",
    "**(This may take some time)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "J-0QbxyK1_51"
   },
   "outputs": [],
   "source": [
    "import pysr\n",
    "\n",
    "# We don't precompile in colab because compiled modules are incompatible static Python libraries:\n",
    "pysr.install(precompile=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vFpyRxmhFqeH"
   },
   "outputs": [],
   "source": [
    "import sympy\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from pysr import PySRRegressor\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gsRMQ7grbDga"
   },
   "source": [
    "# Simple PySR example:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "myTEwdiUFiGL"
   },
   "source": [
    "First, let's learn a simple function\n",
    "\n",
    "$$2.5382 \\cos(x3) + x0^2 - 2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Cb1eb2XuFQh8"
   },
   "outputs": [],
   "source": [
    "# Dataset\n",
    "np.random.seed(0)\n",
    "X = 2 * np.random.randn(100, 5)\n",
    "y = 2.5382 * np.cos(X[:, 3]) + X[:, 0] ** 2 - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cturCkaVjzLs"
   },
   "source": [
    "By default, we will set up 30 populations of expressions (which evolve independently except for migrations), use 4 threads, and use `\"best\"` for our model selection strategy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4nDAAnisdhTc"
   },
   "outputs": [],
   "source": [
    "default_pysr_params = dict(\n",
    "    populations=30,\n",
    "    model_selection=\"best\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N4gANfkaj8ie"
   },
   "source": [
    "PySR can run for arbitrarily long, and continue to find more and more accurate expressions. You can set the total number of cycles of evolution with `niterations`, although there are also a [few more ways](https://github.com/MilesCranmer/PySR/pull/134) to stop execution.\n",
    "\n",
    "**This first execution will take a bit longer to startup, as the library is JIT-compiled. The next execution will be much faster.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "p4PSrO-NK1Wa"
   },
   "outputs": [],
   "source": [
    "# Learn equations\n",
    "model = PySRRegressor(\n",
    "    niterations=30,\n",
    "    binary_operators=[\"plus\", \"mult\"],\n",
    "    unary_operators=[\"cos\", \"exp\", \"sin\"],\n",
    "    **default_pysr_params,\n",
    ")\n",
    "\n",
    "model.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-bsAECbdkQsQ"
   },
   "source": [
    "We can print the model, which will print out all the discovered expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4HR8gknlZz4W"
   },
   "outputs": [],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ME3ddPxXkWQg"
   },
   "source": [
    "We can also view the SymPy format of the best expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IQKOohdpztS7"
   },
   "outputs": [],
   "source": [
    "model.sympy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EHIIPlmClltn"
   },
   "source": [
    "We can also view the SymPy of any other expression in the list, using the index of it in `model.equations_`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GRcxq-TTlpRX"
   },
   "outputs": [],
   "source": [
    "model.sympy(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YMugcGX4tbqj"
   },
   "source": [
    "## Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gIWt5wz5cjXE"
   },
   "source": [
    "`model.equations_` is a Pandas DataFrame. We can export the results in various ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HFGaNL6tbDgi"
   },
   "outputs": [],
   "source": [
    "model.latex()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4hS8kqutcmPQ"
   },
   "source": [
    "These is also `model.sympy(), model.jax(), model.pytorch()`. All of these can take an index as input, to get the result for an arbitrary equation in the list.\n",
    "\n",
    "We can also use `model.predict` for arbitrary equations, with the default equation being the one chosen by `model_selection`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Vbz4IMsk2NYH"
   },
   "outputs": [],
   "source": [
    "ypredict = model.predict(X)\n",
    "ypredict_simpler = model.predict(X, 2)\n",
    "\n",
    "print(\"Default selection MSE:\", np.power(ypredict - y, 2).mean())\n",
    "print(\"Manual selection MSE for index 2:\", np.power(ypredict_simpler - y, 2).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SQDUScGebDgr"
   },
   "source": [
    "# Custom operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qvgVbOoSFtQY"
   },
   "source": [
    "A full list of operators is given here: https://astroautomata.com/PySR/operators,\n",
    "but we can also use any binary or unary operator in `julia`, or define our own as arbitrary functions.\n",
    "\n",
    "Say that we want a command to do quartic powers:\n",
    "\n",
    "$$ y = x_0^4 - 2 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JvXOVqSyFsdr"
   },
   "outputs": [],
   "source": [
    "y = X[:, 0] ** 4 - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-zoqaL8KGSK5"
   },
   "source": [
    "We can do this by passing a string in Julia syntax.\n",
    "\n",
    "We also define the operator in sympy, with `extra_sympy_mappings`, to enable its use in `predict`, and other export functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PoEkpvYuGUdy"
   },
   "outputs": [],
   "source": [
    "model = PySRRegressor(\n",
    "    niterations=5,\n",
    "    populations=40,\n",
    "    binary_operators=[\"plus\", \"mult\"],\n",
    "    unary_operators=[\"cos\", \"exp\", \"sin\", \"quart(x) = x^4\"],\n",
    "    extra_sympy_mappings={\"quart\": lambda x: x**4},\n",
    ")\n",
    "model.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "emn2IajKbDgy"
   },
   "outputs": [],
   "source": [
    "model.sympy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wbWHyOjl2_kX"
   },
   "source": [
    "Since `quart` is arguably more complex than the other operators, you can also give it a different complexity, using, e.g., `complexity_of_operators={\"quart\": 2}` to give it a complexity of 2 (instead of the default 2). You can also define custom complexities for variables and constants (`complexity_of_variables` and `complexity_of_constants`, respectively - both take a single number).\n",
    "\n",
    "\n",
    "One can also add a binary operator, with, e.g., `\"myoperator(x, y) = x^2 * y\"`. All Julia operators that work on scalar 32-bit floating point values are available.\n",
    "\n",
    "Make sure that any operator you add is valid over the real line. So, e.g., you will need to define `\"mysqrt(x) = sqrt(abs(x))\"` to enable it for negative numbers,\n",
    "or, simply have it return a very large number for bad inputs (to prevent negative input in a soft way):\n",
    "`\"mysqrt(x::T) where {T} = (x >= 0) ? x : T(-1e9)\"` (Julia syntax for a template function of input type `T`), which will make `mysqrt(x)` return -10^9 for negative x–hurting the loss of the equation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pEXT4xskbDg0"
   },
   "source": [
    "## Scoring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IyeYbVVOG60w"
   },
   "source": [
    "Using `model_selection=\"best\"`selects the equation with the max score and prints it. But in practice it is best to look through all the equations manually, select an equation above some MSE threshold, and then use the score to select among that loss threshold.\n",
    "\n",
    "Here, \"score\" is defined by:\n",
    "$$ \\text{score} = - \\log(\\text{loss}_i/\\text{loss}_{i-1})/\n",
    "(\\text{complexity}_i - \\text{complexity}_{i-1})$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I3IxmvSQrhfw"
   },
   "source": [
    "This scoring is motivated by the common strategy of looking for drops in the loss-complexity curve.\n",
    "\n",
    "From Schmidt & Lipson (2009) -"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eUeXyoLxrd8o"
   },
   "source": [
    "![F4.large.jpg](data:image/jpeg;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gDZyxsA7bDg9"
   },
   "source": [
    "# Noise example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cJCHdDt6IOou"
   },
   "source": [
    "Here is an example with noise. Known Gaussian noise with $\\sigma$ between 0.1 and 5.0. We record samples of $y$:\n",
    "\n",
    "$$ \\sigma \\sim U(0.1, 5.0) $$\n",
    "$$ \\epsilon \\sim \\mathcal{N}(0, \\sigma^2)$$\n",
    "$$ y = 5\\;\\cos(3.5 x_0) - 1.3 + \\epsilon.$$\n",
    "We have 5 features, say. The weights change the loss function to be:\n",
    "$$MSE = \\sum [(y - f(x))^2*w],$$\n",
    "\n",
    "so in this example, we can set:\n",
    "$$w = 1/\\sigma^2.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "up1RvmwyOdal"
   },
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "N = 3000\n",
    "upper_sigma = 5\n",
    "X = 2 * np.random.rand(N, 5)\n",
    "sigma = np.random.rand(N) * (5 - 0.1) + 0.1\n",
    "eps = sigma * np.random.randn(N)\n",
    "y = 5 * np.cos(3.5 * X[:, 0]) - 1.3 + eps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-EJPDZbP5YEZ"
   },
   "source": [
    "Let's look at this dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sqMqb4nJ5ZR5"
   },
   "outputs": [],
   "source": [
    "plt.scatter(X[:, 0], y, alpha=0.2)\n",
    "plt.xlabel(\"$x_0$\")\n",
    "plt.ylabel(\"$y$\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kaddasbBuDDv"
   },
   "source": [
    "Define some weights to use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3wqz9_sIbDhA"
   },
   "outputs": [],
   "source": [
    "weights = 1 / sigma**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "v8WBYtcZbDhC"
   },
   "outputs": [],
   "source": [
    "weights[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NXWdQSCFuAzV"
   },
   "source": [
    "Let's run PySR again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a07K3KUjOxcp"
   },
   "outputs": [],
   "source": [
    "model = PySRRegressor(\n",
    "    loss=\"myloss(x, y, w) = w * abs(x - y)\",  # Custom loss function with weights.\n",
    "    niterations=20,\n",
    "    populations=20,  # Use more populations\n",
    "    binary_operators=[\"plus\", \"mult\"],\n",
    "    unary_operators=[\"cos\"],\n",
    ")\n",
    "model.fit(X, y, weights=weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CHCMO9CouFLP"
   },
   "source": [
    "Let's see if we get similar results to the true equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oHyUbcg6ggmx"
   },
   "outputs": [],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OchlZZQP8Ums"
   },
   "source": [
    "We can also filter all equations up to 2x the most accurate equation, then select the best score from that list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PB67POLr8b_L"
   },
   "outputs": [],
   "source": [
    "best_idx = model.equations_.query(\n",
    "    f\"loss < {2 * model.equations_.loss.min()}\"\n",
    ").score.idxmax()\n",
    "model.sympy(best_idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SRHTP4x55roh"
   },
   "source": [
    "We can also use `denoise=True`, which will run the input through a Gaussian process to denoise the dataset, before fitting on it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eTGQ4NA78yAw"
   },
   "source": [
    "Let's look at the fit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ezCC0IkS8zFf"
   },
   "outputs": [],
   "source": [
    "plt.scatter(X[:, 0], y, alpha=0.1)\n",
    "y_prediction = model.predict(X, index=best_idx)\n",
    "plt.scatter(X[:, 0], y_prediction)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiple outputs"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For multiple outputs, multiple equations are returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = 2 * np.random.randn(100, 5)\n",
    "y = 1 / X[:, [0, 1, 2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = PySRRegressor(\n",
    "    binary_operators=[\"+\", \"*\"],\n",
    "    unary_operators=[\"inv(x) = 1/x\"],\n",
    "    extra_sympy_mappings={\"inv\": lambda x: 1 / x},\n",
    ")\n",
    "model.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Julia packages and types"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PySR uses [SymbolicRegression.jl](https://github.com/MilesCranmer/SymbolicRegression.jl)\n",
    "as its search backend. This is a pure Julia package, and so can interface easily with any other\n",
    "Julia package.\n",
    "For some tasks, it may be necessary to load such a package.\n",
    "\n",
    "For example, let's say we wish to discovery the following relationship:\n",
    "\n",
    "$$ y = p_{3x + 1} - 5, $$\n",
    "\n",
    "where $p_i$ is the $i$th prime number, and $x$ is the input feature.\n",
    "\n",
    "Let's see if we can discover this using\n",
    "the [Primes.jl](https://github.com/JuliaMath/Primes.jl) package.\n",
    "\n",
    "First, let's get the Julia backend\n",
    "Here, we might choose to manually specify unlimited threads, `-O3`,\n",
    "and `compile_modules=False`, although this will only propagate if Julia has not yet started:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pysr\n",
    "\n",
    "jl = pysr.julia_helpers.init_julia(\n",
    "    julia_kwargs={\"threads\": \"auto\", \"optimize\": 2, \"compiled_modules\": False}\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "`jl` stores the Julia runtime.\n",
    "\n",
    "Now, let's run some Julia code to add the Primes.jl\n",
    "package to the PySR environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jl.eval(\n",
    "    \"\"\"\n",
    "import Pkg\n",
    "Pkg.add(\"Primes\")\n",
    "\"\"\"\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This imports the Julia package manager, and uses it to install\n",
    "`Primes.jl`. Now let's import `Primes.jl`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jl.eval(\"import Primes\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Now, we define a custom operator:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jl.eval(\n",
    "    \"\"\"\n",
    "function p(i::T) where T\n",
    "    if 0.5 < i < 1000\n",
    "        return T(Primes.prime(round(Int, i)))\n",
    "    else\n",
    "        return T(NaN)\n",
    "    end\n",
    "end\n",
    "\"\"\"\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We have created a function `p`, which takes a number `i` of type `T` (e.g., `T=Float64`).\n",
    "`p` first checks whether the input is between 0.5 and 1000.\n",
    "If out-of-bounds, it returns `NaN`.\n",
    "If in-bounds, it rounds it to the nearest integer, computes the corresponding prime number, and then\n",
    "converts it to the same type as input.\n",
    "\n",
    "The equivalent function in Python would be:\n",
    "\n",
    "```python\n",
    "import sympy\n",
    "\n",
    "def p(i):\n",
    "    if 0.5 < i < 1000:\n",
    "        return float(sympy.prime(int(round(i))))\n",
    "    else:\n",
    "        return float(\"nan\")\n",
    "```\n",
    "\n",
    "(However, note that this version assumes 64-bit float input, rather than any input type `T`)\n",
    "\n",
    "Next, let's generate a list of primes for our test dataset.\n",
    "Since we are using PyJulia, we can just call `p` directly to do this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primes = {i: jl.p(i * 1.0) for i in range(1, 999)}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's use this list of primes to create a dataset of $x, y$ pairs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "X = np.random.randint(0, 100, 100)[:, None]\n",
    "y = [primes[3 * X[i, 0] + 1] - 5 + np.random.randn() * 0.001 for i in range(100)]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we have also added a tiny bit of noise to the dataset.\n",
    "\n",
    "Finally, let's create a PySR model, and pass the custom operator. We also need to define the sympy equivalent, which we can leave as a placeholder for now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pysr import PySRRegressor\n",
    "import sympy\n",
    "\n",
    "\n",
    "class sympy_p(sympy.Function):\n",
    "    pass\n",
    "\n",
    "\n",
    "model = PySRRegressor(\n",
    "    binary_operators=[\"+\", \"-\", \"*\", \"/\"],\n",
    "    unary_operators=[\"p\"],\n",
    "    niterations=20,\n",
    "    extra_sympy_mappings={\"p\": sympy_p},\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee30bd41",
   "metadata": {},
   "source": [
    "We are all set to go! Let's see if we can find the true relation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X, y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if all works out, you should be able to see the true relation (note that the constant offset might not be exactly 1, since it is allowed to round to the nearest integer).\n",
    "\n",
    "You can get the sympy version of the best equation with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.sympy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cPc1EDvRbDhL"
   },
   "source": [
    "# High-dimensional input: Neural Nets + Symbolic Regression"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "3hS2kTAbbDhL"
   },
   "source": [
    "In this example, let's learn a high-dimensional problem. **This will use the method proposed in our NeurIPS paper: https://arxiv.org/abs/2006.11287.**\n",
    "\n",
    "Let's consider a time series problem:\n",
    "\n",
    "$$ z = y^2,\\quad y = \\frac{1}{10} \\sum(y_i),\\quad y_i = x_{i0}^2 + 6 \\cos(2*x_{i2})$$\n",
    "\n",
    "Imagine our time series is 10 timesteps. That is very hard for symbolic regression, even if we impose the inductive bias of $$z=f(\\sum g(x_i))$$ - it is the square of the number of possible equations!\n",
    "\n",
    "But, as in our paper, **we can break this problem down into parts with a neural network. Then approximate the neural network with the symbolic regression!**\n",
    "\n",
    "Then, instead of, say, $(10^9)^2=10^{18}$ equations, we only have to consider $2\\times 10^9$ equations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SXJGXySlbDhL"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "rstate = np.random.RandomState(0)\n",
    "\n",
    "N = 100000\n",
    "Nt = 10\n",
    "X = 6 * rstate.rand(N, Nt, 5) - 3\n",
    "y_i = X[..., 0] ** 2 + 6 * np.cos(2 * X[..., 2])\n",
    "y = np.sum(y_i, axis=1) / y_i.shape[1]\n",
    "z = y**2\n",
    "X.shape, y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8ZqGupq_uSgp"
   },
   "source": [
    "## Neural Network definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r2NR0h8-bDhN"
   },
   "source": [
    "So, as described above, let's first use a neural network with the sum inductive bias to solve this problem.\n",
    "\n",
    "Essentially, we will learn two neural networks:\n",
    "- `f`\n",
    "- `g`\n",
    "\n",
    "each defined as a multi-layer perceptron. We will sum over `g` the same way as in our equation, but we won't define the summed part beforehand.\n",
    "\n",
    "Then, we will fit `g` and `f` **separately** using symbolic regression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aca54ffa"
   },
   "source": [
    "> **Warning**\n",
    ">\n",
    "> We import torch *after* already starting PyJulia. This is required due to interference between their C bindings. If you use torch, and then run PyJulia, you will likely hit a segfault. So keep this in mind for mixed deep learning + PyJulia/PySR workflows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nWVfkV_YbDhO"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn, optim\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "import pytorch_lightning as pl\n",
    "\n",
    "hidden = 128\n",
    "total_steps = 30_000\n",
    "\n",
    "\n",
    "def mlp(size_in, size_out, act=nn.ReLU):\n",
    "    return nn.Sequential(\n",
    "        nn.Linear(size_in, hidden),\n",
    "        act(),\n",
    "        nn.Linear(hidden, hidden),\n",
    "        act(),\n",
    "        nn.Linear(hidden, hidden),\n",
    "        act(),\n",
    "        nn.Linear(hidden, size_out),\n",
    "    )\n",
    "\n",
    "\n",
    "class SumNet(pl.LightningModule):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        ########################################################\n",
    "        # The same inductive bias as above!\n",
    "        self.g = mlp(5, 1)\n",
    "        self.f = mlp(1, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        y_i = self.g(x)[:, :, 0]\n",
    "        y = torch.sum(y_i, dim=1, keepdim=True) / y_i.shape[1]\n",
    "        z = self.f(y)\n",
    "        return z[:, 0]\n",
    "\n",
    "    ########################################################\n",
    "\n",
    "    # PyTorch Lightning bookkeeping:\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        x, z = batch\n",
    "        predicted_z = self(x)\n",
    "        loss = F.mse_loss(predicted_z, z)\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        return self.training_step(batch, batch_idx)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=self.max_lr)\n",
    "        scheduler = {\n",
    "            \"scheduler\": torch.optim.lr_scheduler.OneCycleLR(\n",
    "                optimizer,\n",
    "                max_lr=self.max_lr,\n",
    "                total_steps=self.trainer.estimated_stepping_batches,\n",
    "                final_div_factor=1e4,\n",
    "            ),\n",
    "            \"interval\": \"step\",\n",
    "        }\n",
    "        return [optimizer], [scheduler]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kK725aSEuUvG"
   },
   "source": [
    "## Data bookkeeping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KdWVtWUcbDhQ"
   },
   "source": [
    "Put everything into PyTorch and do a train/test split:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0ym19abgbDhR"
   },
   "outputs": [],
   "source": [
    "from multiprocessing import cpu_count\n",
    "\n",
    "Xt = torch.tensor(X).float()\n",
    "zt = torch.tensor(z).float()\n",
    "X_train, X_test, z_train, z_test = train_test_split(Xt, zt, random_state=0)\n",
    "train_set = TensorDataset(X_train, z_train)\n",
    "train = DataLoader(\n",
    "    train_set, batch_size=128, num_workers=cpu_count(), shuffle=True, pin_memory=True\n",
    ")\n",
    "test_set = TensorDataset(X_test, z_test)\n",
    "test = DataLoader(test_set, batch_size=256, num_workers=cpu_count(), pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3dw_NefuudIq"
   },
   "source": [
    "## Train the model with PyTorch Lightning on GPUs:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hhlhLQUBbDhT"
   },
   "source": [
    "Start the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1ldN0999bDhU"
   },
   "outputs": [],
   "source": [
    "pl.seed_everything(0)\n",
    "model = SumNet()\n",
    "model.total_steps = total_steps\n",
    "model.max_lr = 1e-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WWRsu5A9bDhW"
   },
   "source": [
    "PyTorch Lightning trainer object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "33R2nrv-b62w"
   },
   "outputs": [],
   "source": [
    "trainer = pl.Trainer(max_steps=total_steps, accelerator=\"gpu\", devices=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jh91CukM5CkI"
   },
   "source": [
    "Here, we fit the neural network:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TXZdF8k1bDhY"
   },
   "outputs": [],
   "source": [
    "trainer.fit(model, train_dataloaders=train, val_dataloaders=test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uYzk0yU4ulfH"
   },
   "source": [
    "## Latent vectors of network\n",
    "\n",
    "Let's get the input and output of the learned `g` function from the network over some random data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "s2sQLla5bDhb"
   },
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "idx = np.random.randint(0, 10000, size=1000)\n",
    "\n",
    "X_for_pysr = Xt[idx]\n",
    "y_i_for_pysr = model.g(X_for_pysr)[:, :, 0]\n",
    "y_for_pysr = torch.sum(y_i_for_pysr, dim=1) / y_i_for_pysr.shape[1]\n",
    "z_for_pysr = zt[idx]  # Use true values.\n",
    "\n",
    "X_for_pysr.shape, y_i_for_pysr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nCCIvvAGuyFi"
   },
   "source": [
    "## Learning over the network:\n",
    "\n",
    "Now, let's fit `g` using PySR.\n",
    "\n",
    "> **Warning**\n",
    ">\n",
    "> First, let's save the data, because sometimes PyTorch and PyJulia's C bindings interfere and cause the colab kernel to crash. If we need to restart, we can just load the data without having to retrain the network:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nnet_recordings = {\n",
    "    \"g_input\": X_for_pysr.detach().cpu().numpy().reshape(-1, 5),\n",
    "    \"g_output\": y_i_for_pysr.detach().cpu().numpy().reshape(-1),\n",
    "    \"f_input\": y_for_pysr.detach().cpu().numpy().reshape(-1, 1),\n",
    "    \"f_output\": z_for_pysr.detach().cpu().numpy().reshape(-1),\n",
    "}\n",
    "\n",
    "# Save the data for later use:\n",
    "import pickle as pkl\n",
    "\n",
    "with open(\"nnet_recordings.pkl\", \"wb\") as f:\n",
    "    pkl.dump(nnet_recordings, f)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now load the data, including after a crash (be sure to re-run the import cells at the top of this notebook, including the one that starts PyJulia)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle as pkl\n",
    "\n",
    "nnet_recordings = pkl.load(open(\"nnet_recordings.pkl\", \"rb\"))\n",
    "f_input = nnet_recordings[\"f_input\"]\n",
    "f_output = nnet_recordings[\"f_output\"]\n",
    "g_input = nnet_recordings[\"g_input\"]\n",
    "g_output = nnet_recordings[\"g_output\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now fit using a subsample of the data (symbolic regression only needs a small sample to find the best equation):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "51QdHVSkbDhc"
   },
   "outputs": [],
   "source": [
    "rstate = np.random.RandomState(0)\n",
    "f_sample_idx = rstate.choice(f_input.shape[0], size=500, replace=False)\n",
    "\n",
    "model = PySRRegressor(\n",
    "    niterations=20,\n",
    "    binary_operators=[\"plus\", \"sub\", \"mult\"],\n",
    "    unary_operators=[\"cos\", \"square\", \"neg\"],\n",
    ")\n",
    "model.fit(g_input[f_sample_idx], g_output[f_sample_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1a738a33"
   },
   "source": [
    "If this segfaults, restart the notebook, and run the initial imports and PyJulia part, but skip the PyTorch training. This is because PyTorch's C binding tends to interefere with PyJulia. You can then re-run the `pkl.load` cell to import the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xginVMmTu3MZ"
   },
   "source": [
    "## Validation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "6WuaeqyqbDhe"
   },
   "source": [
    "Recall we are searching for $f$ and $g$ such that:\n",
    "$$z=f(\\sum g(x_i))$$ \n",
    "which approximates the true relation:\n",
    "$$ z = y^2,\\quad y = \\frac{1}{10} \\sum(y_i),\\quad y_i = x_{i0}^2 + 6 \\cos(2 x_{i2})$$\n",
    "\n",
    "Let's see how well we did in recovering $g$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "E1_VWQ45bDhf"
   },
   "outputs": [],
   "source": [
    "model.equations_[[\"complexity\", \"loss\", \"equation\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mlU1hidZkgCY"
   },
   "source": [
    "A neural network can easily undo a linear transform (which commutes with the summation), so any affine transform in $g$ is to be expected. The network for $f$ has learned to undo the linear transform.\n",
    "\n",
    "This likely won't find the exact result, but it should find something similar. You may wish to try again but with many more `total_steps` for the neural network (10,000 is quite small!).\n",
    "\n",
    "Then, we can learn another analytic equation for $f$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TntGlQEwbDhk"
   },
   "source": [
    "**Now, we can compose these together to get the time series model!**\n",
    "\n",
    "Think about what we just did: we found an analytical equation for $z$ in terms of $500$ datapoints, under the assumption that $z$ is a function of a sum of another function over an axis:\n",
    "\n",
    "$$ z = f(\\sum_i g(x_i)) $$\n",
    "\n",
    "And we pulled out analytical copies for $g$ using symbolic regression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1QsHVjAVbDhk"
   },
   "source": [
    "# Other PySR Options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S5dO61g1bDhk"
   },
   "source": [
    "The full list of PySR parameters can be found here: https://astroautomata.com/PySR/api"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "pysr_demo.ipynb",
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}