examples/sr/numerical_expression_inference-RNC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numerical expression inference problem: the GEP-RNC algorithm\n",
    "In this example, we aim to identify a mathematicalfunction $f$ from the given input-ouput data such that the function $f$ can produce the expected ouput given a certain input. This is a typical [symbolic regression](https://en.wikipedia.org/wiki/Symbolic_regression) problem:\n",
    "\n",
    "> Symbolic regression is a type of regression analysis that searches the space of mathematical expressions to find the model that best fits a given dataset, both in terms of accuracy and simplicity.\n",
    "\n",
    "which is most commonly solved with genetic programming and its variant, gene expression programming (GEP), presented here. \n",
    "\n",
    "Before continuing this example, you'd better first go through the two fundamental tutorials listed below to get familiar with GEP and *geppy*:\n",
    "+ [Introduction to gene expression programming](https://geppy.readthedocs.io/en/latest/intro_GEP.html)\n",
    "+ [Overview of geppy for Gene Expression Programming (GEP)](https://geppy.readthedocs.io/en/latest/overview.html)\n",
    "\n",
    "The main difference of this problem w.r.t the [Boolean function identification](Boolean_function_identification.ipynb) problem is that generally a mathematical model involves constant coefficients, which is more challenging for both genetic programming (GP) and GEP. The standard way to handle numerical constants in GEP is to add another Dc domain in the genes dedicated to random numerical constant (RNC) evolution, i.e., the GEP-RNC algorithm. Please check Chapter 5 of *Ferreira, Cândida. Gene expression programming: mathematical modeling by an artificial intelligence. Vol. 21. Springer, 2006.* to learn more about the theory.\n",
    "\n",
    "Alternatively, if the involved numerical constants are just simple integers, then the traditional ephemeral numerical constant (ENC) method can also be used, though it is not recommended in GEP. See the example [ENC for numerical expression inference](./numerical_expression_inference-ENC.ipynb).\n",
    "\n",
    "To check the detailed documentation of each function/class in *geppy*, please refer to [library reference](https://geppy.readthedocs.io/en/latest/#library-reference)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geppy as gep\n",
    "from deap import creator, base, tools\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# for reproduction\n",
    "s = 0\n",
    "random.seed(s)\n",
    "np.random.seed(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Synthetic dataset\n",
    "\n",
    "For this simple task, we first choose a ground truth function $f$ to generate a dataset $D$. Then, 50 input-output exampels are generated randomly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    \"\"\"Ground truth function\"\"\"\n",
    "    return -2 * x ** 2 + 11 * x + 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_cases = 100\n",
    "X = np.random.uniform(-10, 10, size=n_cases)   # random numbers in range [-10, 10)\n",
    "Y = f(X) + np.random.normal(size=n_cases) # Gaussian noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the primitives set\n",
    "The first step in GEP (or GP as well) is to specify the primitive set, which contains the elementary building blocks to formulate the model. For this problem, we have:\n",
    "+ function set: the standard arithmetic operators addition (+), subtraction (-), multiplication (*), and division (/).\n",
    "+ terminal set: only the single input 'x' and random numerical constants (RNC).\n",
    "\n",
    "NOTE:\n",
    "\n",
    "- We define a *protected division* to avoid dividing by zero.\n",
    "- Even there may be multiple RNCs in the model, we only need to call `PrimitiveSet.add_rnc` once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def protected_div(x1, x2):\n",
    "    if abs(x2) < 1e-6:\n",
    "        return 1\n",
    "    return x1 / x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator \n",
    "\n",
    "pset = gep.PrimitiveSet('Main', input_names=['x'])\n",
    "pset.add_function(operator.add, 2)\n",
    "pset.add_function(operator.sub, 2)\n",
    "pset.add_function(operator.mul, 2)\n",
    "pset.add_function(protected_div, 2)\n",
    "pset.add_rnc_terminal()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create the individual and population\n",
    "Our objective is to **minimize** the MSE (mean squared error) for data fitting.\n",
    "## Define the indiviudal class, a subclass of *gep.Chromosome*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from deap import creator, base, tools\n",
    "\n",
    "creator.create(\"FitnessMin\", base.Fitness, weights=(-1,))  # to minimize the objective (fitness)\n",
    "creator.create(\"Individual\", gep.Chromosome, fitness=creator.FitnessMin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Register the individual and population creation operations\n",
    "In DEAP, it is recommended to register the operations used in evolution into a *toolbox* to make full use of DEAP functionality. The configuration of individuals in this problem is:\n",
    "+ head length: 6\n",
    "+ number of genes in each chromosome: 2\n",
    "+ RNC array length: 8\n",
    "\n",
    "Generally, more complicated problems require a larger head length and longer chromosomes formed with more genes. **The most important is that we should use the `GeneDc` class for genes to make use of the GEP-RNC algorithm.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "h = 6 # head length\n",
    "n_genes = 2   # number of genes in a chromosome\n",
    "r = 8   # length of the RNC array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "toolbox = gep.Toolbox()\n",
    "toolbox.register('rnc_gen', random.randint, a=-5, b=5)   # each RNC is random integer within [-5, 5]\n",
    "toolbox.register('gene_gen', gep.GeneDc, pset=pset, head_length=h, rnc_gen=toolbox.rnc_gen, rnc_array_length=r)\n",
    "toolbox.register('individual', creator.Individual, gene_gen=toolbox.gene_gen, n_genes=n_genes, linker=operator.add)\n",
    "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n",
    "\n",
    "# compile utility: which translates an individual into an executable function (Lambda)\n",
    "toolbox.register('compile', gep.compile_, pset=pset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define the fitness evaluation function\n",
    "In DEAP, the single objective optimization problem is just a special case of more general multiobjective ones. Since *geppy* is built on top of DEAP, it conforms to this convention. **Even if the fitness only contains one measure, keep in mind that DEAP stores it as an iterable.** \n",
    "\n",
    "Knowing that, you can understand why the evaluation function must return a tuple value (even if it is a 1-tuple). That's also why we set ``weights=(-1,)`` when creating the ``FitnessMax`` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(individual):\n",
    "    \"\"\"Evalute the fitness of an individual: MAE (mean absolute error)\"\"\"\n",
    "    func = toolbox.compile(individual)\n",
    "    Yp = np.array(list(map(func, X)))\n",
    "    return np.mean(np.abs(Y - Yp)),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "toolbox.register('evaluate', evaluate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Register genetic operators\n",
    "Compared with GP and other genetic algorithms, GEP has its own set of genetic operators aside from common mutation and crossover. For details, please check the tutorial [Introduction to gene expression programming](https://geppy.readthedocs.io/en/latest/intro_GEP.html).\n",
    "\n",
    "In the following code, the selection operator is ``tools.selTournament`` provided by DEAP, while all other operators are specially designed for GEP in *geppy*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "toolbox.register('select', tools.selTournament, tournsize=3)\n",
    "# 1. general operators\n",
    "toolbox.register('mut_uniform', gep.mutate_uniform, pset=pset, ind_pb=0.05, pb=1)\n",
    "toolbox.register('mut_invert', gep.invert, pb=0.1)\n",
    "toolbox.register('mut_is_transpose', gep.is_transpose, pb=0.1)\n",
    "toolbox.register('mut_ris_transpose', gep.ris_transpose, pb=0.1)\n",
    "toolbox.register('mut_gene_transpose', gep.gene_transpose, pb=0.1)\n",
    "toolbox.register('cx_1p', gep.crossover_one_point, pb=0.3)\n",
    "toolbox.register('cx_2p', gep.crossover_two_point, pb=0.2)\n",
    "toolbox.register('cx_gene', gep.crossover_gene, pb=0.1)\n",
    "# 2. Dc-specific operators\n",
    "toolbox.register('mut_dc', gep.mutate_uniform_dc, ind_pb=0.05, pb=1)\n",
    "toolbox.register('mut_invert_dc', gep.invert_dc, pb=0.1)\n",
    "toolbox.register('mut_transpose_dc', gep.transpose_dc, pb=0.1)\n",
    "# for some uniform mutations, we can also assign the ind_pb a string to indicate our expected number of point mutations in an individual\n",
    "toolbox.register('mut_rnc_array_dc', gep.mutate_rnc_array_dc, rnc_gen=toolbox.rnc_gen, ind_pb='0.5p')\n",
    "toolbox.pbs['mut_rnc_array_dc'] = 1  # we can also give the probability via the pbs property"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Statistics to be inspected\n",
    "We often need to monitor of progress of an evolutionary program. DEAP offers two classes to handle the boring work of recording statistics. Details are presented in [Computing statistics](http://deap.readthedocs.io/en/master/tutorials/basic/part3.html). In the following, we are intereted in the average/standard deviation/min/max of all the individuals' fitness in each generation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats = tools.Statistics(key=lambda ind: ind.fitness.values[0])\n",
    "stats.register(\"avg\", np.mean)\n",
    "stats.register(\"std\", np.std)\n",
    "stats.register(\"min\", np.min)\n",
    "stats.register(\"max\", np.max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Launch evolution\n",
    "We make use of *geppy*'s builtin algorithm ``gep_rnc`` here to perform the GEP-RNC evolution. A special class from DEAP, `HallOfFame`, is adopted to store the best individuals ever found. Besides, it should be noted that in GEP [*elitism*](https://en.wikipedia.org/wiki/Genetic_algorithm#Elitism) is highly recommended because some genetic operators in GEP are destructive and may destroy the best individual we have evolved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gen\tnevals\tavg    \tstd    \tmin    \tmax    \n",
      "0  \t100   \t81.9249\t27.7577\t54.9895\t261.298\n",
      "1  \t99    \t71.8922\t10.4668\t42.0433\t136.346\n",
      "2  \t99    \t89.6798\t205.708\t38.9218\t2131.62\n",
      "3  \t99    \t69.0112\t17.4721\t28.2459\t165.384\n",
      "4  \t99    \t66.6045\t16.1314\t27.3629\t120.876\n",
      "5  \t99    \t87.5899\t169.74 \t14.3539\t1728.69\n",
      "6  \t99    \t62.2542\t27.1422\t14.3539\t225.294\n",
      "7  \t99    \t58.4688\t29.2628\t14.3539\t228.513\n",
      "8  \t99    \t61.5411\t43.0892\t10.8169\t320.429\n",
      "9  \t99    \t76.703 \t96.8616\t7.82959\t905.788\n",
      "10 \t99    \t65.6228\t52.688 \t7.23691\t350.552\n",
      "11 \t99    \t52.7719\t42.748 \t7.23691\t390.783\n",
      "12 \t99    \t52.6757\t32.2696\t6.19445\t196.143\n",
      "13 \t99    \t58.4056\t67.1411\t6.19445\t603.211\n",
      "14 \t99    \t54.7206\t43.1564\t6.19445\t384.694\n",
      "15 \t99    \t61.7266\t57.6286\t6.19445\t562.3  \n",
      "16 \t99    \t62.236 \t64.4507\t6.19445\t553.836\n",
      "17 \t99    \t54.2323\t26.7546\t5.20662\t126    \n",
      "18 \t99    \t57.36  \t36.9686\t5.20662\t190.35 \n",
      "19 \t99    \t55.89  \t43.3556\t5.20662\t391.671\n",
      "20 \t99    \t55.3062\t33.5315\t5.20662\t196.9  \n",
      "21 \t99    \t64.8551\t67.2205\t5.20662\t461.723\n",
      "22 \t99    \t55.4499\t40.9975\t5.20662\t359.962\n",
      "23 \t99    \t63.9077\t59.7998\t5.20662\t497.032\n",
      "24 \t99    \t60.6148\t45.0208\t2.19233\t352.215\n",
      "25 \t99    \t65.4788\t57.0866\t2.19233\t317.802\n",
      "26 \t99    \t59.7687\t34.3705\t2.19233\t233.702\n",
      "27 \t99    \t55.8954\t35.7615\t2.19233\t229.517\n",
      "28 \t99    \t65.2489\t60.4526\t2.19233\t350.07 \n",
      "29 \t99    \t55.2768\t43.1746\t2.19233\t275.208\n",
      "30 \t99    \t62.0411\t57.9148\t2.19233\t384.602\n",
      "31 \t99    \t56.4574\t44.4184\t2.19233\t400.559\n",
      "32 \t99    \t61.116 \t46.1296\t2.19233\t310.008\n",
      "33 \t99    \t59.9242\t64.5759\t2.19233\t527.79 \n",
      "34 \t99    \t52.0573\t47.8412\t2.19233\t418.603\n",
      "35 \t99    \t51.1077\t34.7466\t2.19233\t172.653\n",
      "36 \t99    \t51.9047\t35.1705\t1.81533\t153.455\n",
      "37 \t99    \t53.2559\t54.2717\t1.26424\t409.769\n",
      "38 \t99    \t48.9181\t54.9365\t1.26424\t469.701\n",
      "39 \t99    \t61.3807\t50.6096\t1.26424\t321.551\n",
      "40 \t99    \t56.7819\t62.6169\t1.26424\t584.837\n",
      "41 \t99    \t56.4688\t56.099 \t1.26424\t400.877\n",
      "42 \t99    \t70.1829\t84.4915\t1.26424\t572.534\n",
      "43 \t99    \t67.2872\t51.1359\t1.26424\t344.732\n",
      "44 \t99    \t70.4533\t51.6825\t1.26424\t360.025\n",
      "45 \t99    \t56.8468\t27.1994\t1.26424\t148.491\n",
      "46 \t99    \t60.0492\t53.6085\t1.26424\t423.831\n",
      "47 \t99    \t60.5778\t51.8213\t1.26424\t456.758\n",
      "48 \t99    \t57.3062\t29.7781\t1.26424\t154.823\n",
      "49 \t99    \t64.3703\t47.9095\t1.26424\t380.063\n",
      "50 \t99    \t67.0773\t34.8398\t1.26424\t197.65 \n",
      "51 \t99    \t65.6332\t67.6813\t1.26424\t597.116\n",
      "52 \t99    \t66.4645\t50.6512\t1.26424\t309.812\n",
      "53 \t99    \t57.2602\t42.755 \t1.26424\t340.154\n",
      "54 \t99    \t59.8096\t44.072 \t1.26424\t343.946\n",
      "55 \t99    \t57.117 \t46.0569\t1.26424\t300.682\n",
      "56 \t99    \t52.1693\t35.121 \t1.26424\t225.555\n",
      "57 \t99    \t56.4192\t39.8198\t1.26424\t321.693\n",
      "58 \t99    \t64.084 \t66.2973\t1.26424\t553.953\n",
      "59 \t99    \t68.8069\t64.7468\t1.26424\t565.081\n",
      "60 \t99    \t113.454\t416.594\t1.26424\t4195.06\n",
      "61 \t99    \t78.2475\t186.809\t1.26424\t1886.92\n",
      "62 \t99    \t58.511 \t36.6339\t1.26424\t261.745\n",
      "63 \t99    \t69.9439\t55.7433\t1.26424\t389.991\n",
      "64 \t99    \t60.1303\t32.2181\t1.26424\t195.568\n",
      "65 \t99    \t67.1424\t61.3555\t1.26424\t443.46 \n",
      "66 \t99    \t59.0999\t41.8023\t1.053  \t289.554\n",
      "67 \t99    \t69.8371\t66.0053\t1.053  \t387.258\n",
      "68 \t99    \t57.724 \t44.2179\t1.053  \t318.028\n",
      "69 \t99    \t55.4516\t38.9926\t1.053  \t325.076\n",
      "70 \t99    \t74.1981\t90.6421\t1.053  \t713.565\n",
      "71 \t99    \t56.1714\t28.4973\t1.053  \t116.976\n",
      "72 \t99    \t71.9521\t130.616\t1.053  \t1275.08\n",
      "73 \t99    \t52.566 \t29.3444\t1.053  \t122.118\n",
      "74 \t99    \t57.2833\t48.0591\t1.053  \t335.459\n",
      "75 \t99    \t58.0169\t47.4673\t1.053  \t340.131\n",
      "76 \t99    \t66.5954\t72.7518\t0.862385\t604.953\n",
      "77 \t99    \t67.4795\t63.2768\t0.862385\t412.567\n",
      "78 \t99    \t52.1313\t31.9782\t0.862385\t154.569\n",
      "79 \t99    \t60.9233\t54.1341\t0.862385\t337.642\n",
      "80 \t99    \t70.3822\t69.1806\t0.862385\t404.612\n",
      "81 \t99    \t60.349 \t60.8916\t0.862385\t350.117\n",
      "82 \t99    \t74.5196\t108.664\t0.862385\t1007.5 \n",
      "83 \t99    \t55.9338\t42.6623\t0.862385\t238.225\n",
      "84 \t99    \t61.2702\t40.6852\t0.862385\t290.594\n",
      "85 \t99    \t56.5529\t48.7812\t0.862385\t281.886\n",
      "86 \t99    \t55.0713\t49.452 \t0.862385\t305.622\n",
      "87 \t99    \t58.2677\t55.9728\t0.862385\t329.931\n",
      "88 \t99    \t50.6493\t45.6795\t0.862385\t315.024\n",
      "89 \t99    \t83.8576\t278.425\t0.862385\t2812.45\n",
      "90 \t99    \t61.3165\t48.8682\t0.862385\t333.942\n",
      "91 \t99    \t70.0793\t72.1216\t0.862385\t469.624\n",
      "92 \t99    \t73.0283\t67.3937\t0.862385\t397.327\n",
      "93 \t99    \t65.8455\t57.3543\t0.862385\t320.251\n",
      "94 \t99    \t59.2353\t44.6736\t0.862385\t281.686\n",
      "95 \t99    \t62.9311\t59.0233\t0.862385\t366.806\n",
      "96 \t99    \t60.0013\t46.0675\t0.862385\t340.154\n",
      "97 \t99    \t59.7797\t36.6043\t0.862385\t314.996\n",
      "98 \t99    \t66.7211\t49.5114\t0.862385\t463.248\n",
      "99 \t99    \t68.0917\t46.0289\t0.862385\t336.926\n",
      "100\t99    \t68.4653\t50.176 \t0.862385\t324.995\n"
     ]
    }
   ],
   "source": [
    "# size of population and number of generations\n",
    "n_pop = 100\n",
    "n_gen = 100\n",
    "\n",
    "pop = toolbox.population(n=n_pop)\n",
    "hof = tools.HallOfFame(3)   # only record the best three individuals ever found in all generations\n",
    "\n",
    "# start evolution\n",
    "pop, log = gep.gep_simple(pop, toolbox, n_generations=n_gen, n_elites=1,\n",
    "                          stats=stats, hall_of_fame=hof, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let's check the best individuals ever evolved.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add(\n",
      "\tmul(sub(add(x, x), sub(-4, -3)), sub(5, x)),\n",
      "\tsub(add(sub(-3, -5), sub(x, -4)), sub(-2, x))\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(hof[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *[optional]* Post-processing: simplification and visualization\n",
    "## Symbolic simplification of the final solution\n",
    "The original solution seems a little complicated, which may contain many redundancies, for example, `protected_div(x, x)` is just 1. We can perform symbolic simplification of the final result by `geppy.simplify` which depends on `sympy` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symplified best individual: \n",
      "-2*x**2 + 11*x + 13\n"
     ]
    }
   ],
   "source": [
    "best_ind = hof[0]\n",
    "symplified_best = gep.simplify(best_ind)\n",
    "print('Symplified best individual: ')\n",
    "print(symplified_best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see from the above simplified expression, the *truth model* has been successfully found. Due to the existence of Gaussian noise, the minimum mean absolute error （MAE) is still not zero even the best individual represents the true model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization\n",
    "If you are interested in the expression tree corresponding to the individual, i.e., the genotype/phenotype system, *geppy* supports tree visualization by the `graph` and the `export_expression_tree` functions:\n",
    "\n",
    "- `graph` only outputs the nodes and links information to describe the tree topology, with which you can render the tree with tools you like;\n",
    "- `export_expression_tree` implements tree visualization with data generated by `graph` internally using the `graphviz` package. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    " # we want use symbol labels instead of words in the tree graph\n",
    "rename_labels = {'add': '+', 'sub': '-', 'mul': '*', 'protected_div': '/'}  \n",
    "gep.export_expression_tree(best_ind, rename_labels, 'data/numerical_expression_tree.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# show the above image here for convenience\n",
    "from IPython.display import Image\n",
    "Image(filename='data/numerical_expression_tree.png') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discussion\n",
    "If only integer constants are involved, then the GEP-RNC algorithm is very effective. If the constants are general real numbers, then more advanced techniques like local search may be more suitable.\n",
    "\n",
    "Alternatively, the ephemeral numerical constant (ENC) based method can also be adopted here. Please check [ENC for numerical expression inference](./numerical_expression_inference-ENC.ipynb).\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}