{ "cells": [ { "cell_type": "markdown", "id": "cf6e8f82", "metadata": {}, "source": [ "# Tutorial - Part 1\n", "\n", "This is the first part of the QuickSR tutorial. This section provides the minimal steps required to perform symbolic regression on a synthetic dataset." ] }, { "cell_type": "markdown", "id": "8cc6923b", "metadata": {}, "source": [ "**Dependencies**\n", "\n", "\n", "First of all, we need to import QuickSR and other dependencies" ] }, { "cell_type": "code", "execution_count": 1, "id": "5576b0cd", "metadata": {}, "outputs": [], "source": [ "from quicksr import *\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "id": "8d341684", "metadata": {}, "source": [ "**Dataset**\n", "\n", "For simplicity, we'll use a synthetic, single-dimensional dataset, for which we already know the exact algebraic formula:" ] }, { "cell_type": "code", "execution_count": 2, "id": "769e9794", "metadata": {}, "outputs": [], "source": [ "X = np.linspace(-5, 5, 25)\n", "y = 2.5382 * np.cos(X)*X + X*X - 0.5" ] }, { "cell_type": "markdown", "id": "a25afef4", "metadata": {}, "source": [ "Here's how the dataset looks like:" ] }, { "cell_type": "code", "execution_count": 3, "id": "b4c608ad", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure()\n", "plt.scatter(X, y)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "ebcfcf90", "metadata": {}, "source": [ "Now, our goal is to fit a curve to these 25 points. If we are lucky, we expect to find exact the expression that we have used to generate the dataset." ] }, { "cell_type": "markdown", "id": "a6aae755", "metadata": {}, "source": [ "**Configuration**\n", "\n", "Let's start by defining the constants and \"hyperparameters\" of symbolic regression. First, the constant NVARS denotes the number of features present in our dataset. Since we only have a single feature (the x-axis values), we set NVARS to one." ] }, { "cell_type": "code", "execution_count": 4, "id": "c07b795b", "metadata": {}, "outputs": [], "source": [ "NVARS = 1" ] }, { "cell_type": "markdown", "id": "e68f1cbc", "metadata": {}, "source": [ "An important hyperparameter we need to determine is the population size. This is the number of candidate expressions that will exist at every generation. For now, let's set it to an arbitrary value." ] }, { "cell_type": "code", "execution_count": 5, "id": "efd0e9b8", "metadata": {}, "outputs": [], "source": [ "NPOPULATION = 11200" ] }, { "cell_type": "markdown", "id": "5a4fb447", "metadata": {}, "source": [ "QuickSR partitions the population into equal-size groups called islands. Each island is assigned to its own CPU core. The associated GPU kernels are also executed on the island's own stream. Therefore, it is reasonable to set the number of islands to the maximum level of task parallelism supported by the machine. Since this notebook was executed on a 28-core CPU, we use 28 here. You can adjust this value according to your own environment. With this choice, we have 11200 / 28 = 400 expressions per island." ] }, { "cell_type": "code", "execution_count": 6, "id": "2c0f4496", "metadata": {}, "outputs": [], "source": [ "NISLANDS = 28" ] }, { "cell_type": "markdown", "id": "17d10c25", "metadata": {}, "source": [ "In QuickSR we have two types of constants in candidate expressions:\n", "\n", "1. Regular constants \n", "2. Trainable constants (also referred to as trainable weights or trainable parameters)\n", "\n", "Regular constants arise naturally from algebraic operations. For example, the constant $2$ can arise from the simplification of the expression $(x + x) / x$.\n", "\n", "Trainable constants, on the other hand, are explicitly inserted into candidate expressions. Initially, these have random values. Before an expression is evaluated for loss, these constants are learned using gradient descent and backpropagation. \n", "For example, the constants $w_{0}$ and $w_{1}$ in the expression $w_{0} + x \\times w_{1}$ are trainable constants.\n", "\n", "To determine the maximum number of distinct trainable constants, we use NWEIGHTS. For now, let's set it to two." ] }, { "cell_type": "code", "execution_count": 7, "id": "50bc39bd", "metadata": {}, "outputs": [], "source": [ "NWEIGHTS = 2" ] }, { "cell_type": "markdown", "id": "a471e6bd", "metadata": {}, "source": [ "**The Model**\n", "\n", "In this step, we create a symbolic regression model using the aforemention configuration parameters. In addition, we limit the depth of candidate expressions in the initial population to one, meaning that the initial population can only consists of variables (which is just the single feature x) and constants (e.g., 2.3). Anything else will be generated during later genetic operations.\n", "\n", "It is important to note that we can actually configure a lot more things here, but we will continue with the default choices in this tutorial." ] }, { "cell_type": "code", "execution_count": 8, "id": "2cb25b87", "metadata": {}, "outputs": [], "source": [ "model = SymbolicRegressionModel(NVARS, NWEIGHTS, NPOPULATION, NISLANDS, \n", " initialization=GrowInitialization(init_depth=1))" ] }, { "cell_type": "markdown", "id": "56eaa950", "metadata": {}, "source": [ "**Training**\n", "\n", "It is finally the time to train the model and see what expression it suggests. However, before continuing, we need to determine two more hyperparameters.\n", "\n", "1. ngenerations\n", "2. nsupergenerations\n", "\n", "In QuickSR, every island evolves in isolation from other islands for $ngenerations$ many iterations. At the end of the isolation step, the best solution found by $island_{(i)}$ replaces the worst solution found by $island_{(i+1)}$, which is called the migration step. The entirety of this two-step process is repeated for $nsupergenerations$ times. Thus, the total number of iterations is given by $ngenerations \\times nsupergenerations$.\n", "\n", "Let's set ngenerations to 5 and nsupergenerations to 4, yielding a total of 20 iterations. We will also use 500 epochs in gradient descent to fit the trainable constants. This can take some time." ] }, { "cell_type": "code", "execution_count": 9, "id": "0a68d74c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Island 12 Best solution: (x0) * ((x0) + (w0=-0.937014)) Loss: 13.4559\n", "Island 0 Best solution: ((x0) - (w1=0.931526)) * (x0) Loss: 13.4561\n", "Island 27 Best solution: ((x0) + (cos(x0))) * ((w0=-0.531155) + (x0)) Loss: 5.33177\n", "Island 21 Best solution: ((x0) + (w1=-0.936625)) * (x0) Loss: 13.4559\n", "Island 8 Best solution: ((w0=-0.934931) + (x0)) * (x0) Loss: 13.4559\n", "Island 7 Best solution: (x0) * ((x0) + (w1=-0.936529)) Loss: 13.4559\n", "Island 14 Best solution: (sin(x0)) + (((x0) + (w0=-0.861429)) * (x0)) Loss: 14.547\n", "Island 4 Best solution: ((x0) * (x0)) - (x0) Loss: 13.4921\n", "Island 16 Best solution: ((x0) * (x0)) - (((x0) - (w0=-0.124843)) + (w1=0.520710)) Loss: 13.2633\n", "Island 2 Best solution: ((x0) + (w0=-0.935558)) * (x0) Loss: 13.4559\n", "Island 18 Best solution: relu((x0) * (((x0) - (w0=0.888435)) - (w1=0.056183))) Loss: 13.4309\n", "Island 13 Best solution: ((x0) - (w0=0.925074)) * (x0) Loss: 13.4571\n", "Island 3 Best solution: (x0) * ((relu((x0) + (x0))) + (w0=-4.781519)) Loss: 11.2703\n", "Island 22 Best solution: ((w0=-0.933644) + (x0)) * (x0) Loss: 13.456\n", "Island 9 Best solution: ((x0) * (x0)) - (((x0) * (cos(x0))) / (w1=-0.393980)) Loss: 0.25\n", "Island 10 Best solution: ((x0) * (x0)) - (x0) Loss: 13.4921\n", "Island 5 Best solution: (w1=-2.514902) * ((x0) * (((x0) / (w1=-2.514902)) - (cos(x0)))) Loss: 0.25178\n", "Island 26 Best solution: ((w1=-0.970122) * (x0)) * ((w0=0.949610) - (x0)) Loss: 13.319\n", "Island 1 Best solution: ((w0=0.965956) - (x0)) * ((x0) * (w1=-0.969196)) Loss: 13.3167\n", "Island 11 Best solution: (x0) * ((x0) + (w0=-0.936588)) Loss: 13.4559\n", "Island 6 Best solution: ((x0) - (w0=0.937380)) * (x0) Loss: 13.4559\n", "Island 20 Best solution: ((sin((x0) + (w0=1.096928))) + (x0)) * ((x0) * (w0=1.096928)) Loss: 9.40935\n", "Island 15 Best solution: (x0) * ((x0) + (w1=-0.936660)) Loss: 13.4559\n", "Island 19 Best solution: (x0) * ((x0) - (w1=0.935518)) Loss: 13.4559\n", "Island 24 Best solution: (x0) * ((x0) + (cos((x0) + (w1=-0.025606)))) Loss: 7.99961\n", "Island 23 Best solution: (((cos(x0)) - (1.000000)) + (x0)) * ((w0=0.414565) + (x0)) Loss: 4.92693\n", "Island 25 Best solution: ((x0) * (x0)) - (x0) Loss: 13.4921\n", "Island 17 Best solution: ((cos(x0)) - ((w0=0.947905) - (x0))) * ((x0) * (w0=0.947905)) Loss: 6.23782\n", "Global best solution: ((x0) * (x0)) - (((x0) * (cos(x0))) / (w1=-0.393980)) Loss: 0.25\n", "\n", "Island 6 Best solution: (w1=-1.292484) * ((((((((x0) / (w1=-1.292484)) - (cos(x0))) * (w0=0.968955)) * (w1=-1.292484)) / (w1=-1.292484)) - (cos(x0))) * (x0)) Loss: 0.110965\n", "Island 8 Best solution: ((x0) + (w0=-0.531084)) * ((cos(x0)) + (x0)) Loss: 5.33177\n", "Island 11 Best solution: (x0) * ((x0) + (w0=-0.936556)) Loss: 13.4559\n", "Island 3 Best solution: relu((x0) * (((cos(x0)) + (w1=0.355787)) + (((w0=-0.559416) + (cos(x0))) + (x0)))) Loss: 0.908509\n", "Island 19 Best solution: (x0) * ((x0) - (w1=0.936699)) Loss: 13.4559\n", "Island 12 Best solution: (x0) * ((x0) + (sin((x0) - (w1=-1.530380)))) Loss: 8.00058\n", "Island 22 Best solution: (x0) * ((x0) + (cos(x0))) Loss: 8.0091\n", "Island 16 Best solution: (x0) * ((x0) + ((cos(x0)) * (w0=2.468650))) Loss: 0.265863\n", "Island 24 Best solution: ((((cos(x0)) - (cos((x0) + (x0)))) + (x0)) + ((cos(x0)) - (1.000000))) * ((w0=0.407831) + (x0)) Loss: 2.84369\n", "Island 9 Best solution: ((x0) * ((w1=0.969165) * (x0))) - ((w0=-2.528324) * ((cos(x0)) * (x0))) Loss: 0.111133\n", "Island 14 Best solution: (x0) * (((x0) + (cos(x0))) - (w0=0.570696)) Loss: 5.10008\n", "Island 23 Best solution: (((cos(x0)) / (w0=0.381831)) + (x0)) * ((w1=0.969165) * (x0)) Island 21 Best solution: relu(((cos(x0)) + ((x0) + (w1=-0.571935))) * (x0)) Loss: 5.10016\n", "Loss: 0.110814\n", "Island 5 Best solution: (w1=-1.283511) * ((x0) * ((((x0) / (w0=-1.325603)) - (cos(x0))) - (cos(x0)))) Loss: 0.113661\n", "Island 7 Best solution: (((x0) - (w1=0.043964)) + (cos(x0))) * ((x0) - (w0=0.488436)) Loss: 5.32922\n", "Island 0 Best solution: ((sin((x0) + (w1=1.492645))) * (x0)) + (((x0) + (w0=-0.190505)) * ((x0) + (cos(x0)))) Loss: 0.881243\n", "Island 17 Best solution: (((w0=2.179224) * (cos(x0))) + (x0)) * (x0) Loss: 0.672588\n", "Island 1 Best solution: (((x0) + (cos(x0))) + (cos(x0))) * ((w1=-0.150720) + (x0)) Loss: 0.957409\n", "Island 4 Best solution: (x0) * ((x0) + (cos(x0))) Loss: 8.0091\n", "Island 2 Best solution: (((x0) - ((cos(x0)) * (w0=-1.044665))) * (x0)) - (x0) Loss: 6.641\n", "Island 13 Best solution: (x0) * ((x0) + (cos(x0))) Loss: 8.0091\n", "Island 27 Best solution: ((cos(x0)) + ((w0=0.188107) + ((cos(x0)) + ((w1=-0.581908) + (x0))))) * ((x0) + (w0=0.188107)) Loss: 0.786014\n", "Island 26 Best solution: ((x0) * (x0)) + ((w1=2.522222) * ((cos(x0)) * (x0))) Loss: 0.250837\n", "Island 15 Best solution: (((w1=-0.546676) + (x0)) * ((cos(x0)) + (x0))) + (w1=-0.546676) Loss: 4.98454\n", "Island 25 Best solution: (((cos(x0)) + (x0)) + (cos(x0))) * (x0) Loss: 1.19989\n", "Island 18 Best solution: ((cos((x0) + (0.000000))) - (((cos((w0=0.998434) * (x0))) * (w1=-1.420815)) - (x0))) * (x0) Loss: 0.294657\n", "Island 20 Best solution: ((sin((x0) + (w0=1.518123))) + (x0)) * ((x0) + (w1=-0.535243)) Loss: 5.30697\n", "Island 10 Best solution: ((x0) * (x0)) - (((cos(x0)) * (x0)) / (w1=-0.393980)) Loss: 0.25\n", "Global best solution: (((cos(x0)) / (w0=0.381831)) + (x0)) * ((w1=0.969165) * (x0)) Loss: 0.110814\n", "\n", "Island 1 Best solution: ((cos(x0)) + ((cos(x0)) + ((cos(x0)) + (x0)))) * ((x0) + ((relu((w0=0.273044) - (cos(x0)))) * (w0=0.273044))) Loss: 0.257732\n", "Island 24 Best solution: ((w1=0.969165) * (x0)) * (((cos(x0)) / (w0=0.381831)) + (x0)) Loss: 0.110814\n", "Island 22 Best solution: ((cos(x0)) + ((x0) + (w0=-0.569545))) * (x0) Loss: 5.10003\n", "Island 4 Best solution: (((x0) + ((cos(cos(x0))) + (cos(x0)))) + ((w1=-1.018193) + (cos(x0)))) * (x0) Loss: 0.434603\n", "Island 12 Best solution: ((x0) + (sin((w0=1.013358) + (x0)))) * ((cos((w0=1.013358) * (x0))) + (x0)) Loss: 3.79948\n", "Island 13 Best solution: (x0) * (((x0) + (cos(x0))) - (w0=0.568583)) Loss: 5.10001\n", "Island 15 Best solution: ((((cos(x0)) + ((w0=0.986419) * (((x0) * (w0=0.986419)) + (cos(x0))))) + (w1=0.791313)) - (1.000000)) * (x0) Loss: 0.737316\n", "Island 8 Best solution: ((w1=-0.199862) + (((cos(x0)) + (x0)) + (cos(x0)))) * (x0) Loss: 0.843763\n", "Island 9 Best solution: ((x0) * ((w1=0.969165) * (x0))) - ((w0=-2.536289) * ((cos(x0)) * (x0))) Loss: 0.110826\n", "Island 25 Best solution: (x0) * (((cos(x0)) * (w1=2.537668)) + (x0)) Loss: 0.250001\n", "Island 20 Best solution: (x0) * (((sin((x0) + (w0=1.523799))) + (x0)) + ((cos(x0)) * (w0=1.523799))) Loss: 0.233082\n", "Island 11 Best solution: ((((x0) * (x0)) - (w0=0.272751)) - (w0=0.272751)) - (((cos(x0)) * (x0)) / (w1=-0.393980)) Loss: 0.00207048\n", "Island 17 Best solution: (((x0) + ((cos(x0)) * (w0=2.613319))) * (w1=0.969447)) * (x0) Loss: 0.110898\n", "Island 19 Best solution: (((w0=-0.030835) * (x0)) - (((cos(x0)) * (w1=-2.406373)) - (x0))) * (x0) Loss: 0.167803\n", "Island 21 Best solution: relu(((((x0) + (w1=-0.220663)) + (cos(x0))) * (w0=0.958101)) * ((x0) + (cos(x0)))) Loss: 1.46135\n", "Island 3 Best solution: (((x0) + ((w1=-0.030438) * (cos(x0)))) + ((x0) * (w1=-0.030438))) * (((w0=2.643816) * (cos(x0))) + (x0)) Loss: 0.0922868\n", "Island 14 Best solution: (((w0=0.393980) * (x0)) + (cos(x0))) * ((x0) / (w0=0.393980)) Loss: 0.25\n", "Island 5 Best solution: (w1=-1.269780) * ((x0) * ((((x0) / (w0=-1.310237)) - (cos(x0))) - (cos(x0)))) Loss: 0.11082\n", "Island 23 Best solution: (((cos(x0)) / (w0=0.381831)) + (x0)) * ((w1=0.969165) * (x0)) Loss: 0.110814\n", "Island 26 Best solution: ((x0) * (x0)) + ((x0) * ((w1=2.538164) * (cos(x0)))) Loss: 0.25\n", "Island 10 Best solution: ((x0) * ((x0) * (w0=0.969165))) - (((x0) * (cos(x0))) / (w1=-0.393980)) Loss: 0.110814\n", "Island 7 Best solution: (w1=-1.288981) * ((((((((x0) / (w1=-1.288981)) - (cos(x0))) * (w0=0.969164)) * (w1=-1.288981)) / (w1=-1.288981)) - (cos(x0))) * (x0)) Loss: 0.110814\n", "Island 18 Best solution: (w1=1.607653) * ((((sin((w1=1.607653) + (x0))) - (((x0) * (w0=0.630749)) - (x0))) * (w1=1.607653)) * (x0)) Loss: 0.065182\n", "Island 0 Best solution: ((w0=0.121811) + (x0)) * ((((cos(x0)) + ((x0) / (w1=1.022625))) + (cos(x0))) + (cos(x0))) Loss: 0.635791\n", "Island 27 Best solution: ((x0) * (x0)) + ((w1=2.538085) * ((cos(x0)) * (x0))) Loss: 0.25\n", "Island 6 Best solution: (w1=-1.268650) * ((x0) * ((((x0) / (w0=-1.308976)) - (cos(x0))) - (cos(x0)))) Loss: 0.110817\n", "Island 16 Best solution: ((x0) + ((w0=2.743777) * (cos(x0)))) * (((cos(x0)) * (w1=-0.217937)) + (x0)) Loss: 0.0977606\n", "Island 2 Best solution: ((x0) * (w0=0.973612)) * (((cos(x0)) * (w1=1.527770)) + ((cos(x0)) + (x0))) Loss: 0.133219\n", "Global best solution: ((((x0) * (x0)) - (w0=0.272751)) - (w0=0.272751)) - (((cos(x0)) * (x0)) / (w1=-0.393980)) Loss: 0.00207048\n", "\n", "Island 17 Best solution: ((x0) + ((w0=2.743777) * (cos(x0)))) * (((cos(x0)) * (w1=-0.217937)) + (x0)) Loss: 0.0977606\n", "Island 4 Best solution: ((x0) + ((w0=2.674937) * (cos(x0)))) * (((w1=-0.029810) * ((cos(x0)) + (x0))) + (((w1=-0.029810) * (cos(x0))) + (x0))) Loss: 0.0776706\n", "Island 27 Best solution: ((x0) * (x0)) + ((x0) * ((w1=2.538164) * (cos(x0)))) Loss: 0.25\n", "Island 16 Best solution: ((x0) + ((w0=2.761085) * (cos(x0)))) * (((cos(x0)) * (w1=-0.229538)) + (x0)) Loss: 0.0959706\n", "Island 22 Best solution: (x0) * ((((x0) + (w0=-0.197687)) + (cos(x0))) + (cos(x0))) Loss: 0.843758\n", "Island 20 Best solution: (((w0=-0.030835) * (x0)) - (((cos(x0)) * (w1=-2.406373)) - (x0))) * (x0) Loss: 0.167803\n", "Island 8 Best solution: ((((((x0) / (w1=-1.288978)) - (cos(x0))) * (w0=0.969164)) - (cos(x0))) * (x0)) * (w1=-1.288978) Loss: 0.110814\n", "Island 5 Best solution: (w1=-1.269134) * ((x0) * ((((x0) / (w0=-1.309516)) - (cos(x0))) - (cos(x0)))) Loss: 0.110814\n", "Island 12 Best solution: (((((((x0) * (x0)) - (w0=-0.166747)) - (w0=-0.166747)) - (((cos(x0)) * (x0)) / (w1=-0.787959))) - (w0=-0.166747)) - (1.000000)) - (((cos(x0)) * (x0)) / (w1=-0.787959)) Loss: 5.89404e-08\n", "Island 10 Best solution: (((x0) * (w0=0.969165)) * (x0)) - (((x0) * (cos(x0))) / (w1=-0.393980)) Loss: 0.110814\n", "Island 19 Best solution: (w1=1.607653) * ((((sin((w1=1.607653) + (x0))) - (((x0) * (w0=0.630749)) - (x0))) * (w1=1.607653)) * (x0)) Loss: 0.065182\n", "Island 1 Best solution: ((cos(x0)) + ((cos(x0)) + ((x0) + (cos(x0))))) * (((w0=-0.347165) * (cos(x0))) + (x0)) Loss: 0.184038\n", "Island 18 Best solution: (w1=1.607655) * (((w1=1.607655) * ((sin((w1=1.607655) + (x0))) - (((w0=0.630750) * (x0)) - (x0)))) * (x0)) Loss: 0.0651819\n", "Island 6 Best solution: (((((x0) / (w1=-1.309488)) - (cos(x0))) - (cos(x0))) * (x0)) * (w0=-1.269109) Loss: 0.110814\n", "Island 9 Best solution: (((x0) * (x0)) + (w0=-0.394758)) - (((x0) * (cos(x0))) / (w0=-0.394758)) Loss: 0.0111579\n", "Island 24 Best solution: ((x0) + ((cos(x0)) / (w0=0.381831))) * ((x0) * (w1=0.969165)) Loss: 0.110814\n", "Island 7 Best solution: (w1=-1.268650) * ((x0) * ((((x0) / (w0=-1.308976)) - (cos(x0))) - (cos(x0)))) Loss: 0.110817\n", "Island 25 Best solution: ((w1=0.969165) * (x0)) * (((cos(x0)) / (w0=0.381831)) + (x0)) Loss: 0.110814\n", "Island 23 Best solution: (((cos(x0)) / (w0=0.381831)) + (x0)) * ((w1=0.969165) * (x0)) Loss: 0.110814\n", "Island 11 Best solution: ((((x0) * (x0)) - (w0=0.250004)) - (w0=0.250004)) - (((x0) * (cos(x0))) / (w1=-0.393980)) Loss: 5.51772e-11\n", "Island 0 Best solution: ((x0) * (x0)) + (((cos(x0)) * ((x0) + (w0=0.060849))) * (w1=2.531779)) Loss: 0.234816\n", "Island 14 Best solution: ((x0) / (w0=0.393980)) * (((x0) * (w1=0.381832)) + (cos(x0))) Loss: 0.110814\n", "Island 26 Best solution: (x0) * ((x0) + ((cos(x0)) * (w1=2.538108))) Loss: 0.25\n", "Island 3 Best solution: (((x0) + ((w1=-0.030854) * (cos(x0)))) + ((x0) * (w1=-0.030854))) * (((w0=2.651284) * (cos(x0))) + (x0)) Loss: 0.0921245\n", "Island 15 Best solution: ((x0) / (w0=0.393980)) * ((cos(x0)) + ((x0) * (w1=0.381832))) Loss: 0.110814\n", "Island 21 Best solution: (x0) * ((((x0) + ((w1=-0.038990) * (x0))) + (sin((w0=1.623254) + (x0)))) + ((cos(x0)) * (w0=1.623254))) Loss: 0.100114\n", "Island 13 Best solution: (x0) * ((x0) + ((cos(x0)) + ((w1=0.170471) + ((cos(x0)) + (cos(x0)))))) Loss: 0.687144\n", "Island 2 Best solution: ((w0=0.969291) * (x0)) * (((cos(x0)) * (w1=2.616432)) + (x0)) Loss: 0.110831\n", "Global best solution: ((((x0) * (x0)) - (w0=0.250004)) - (w0=0.250004)) - (((x0) * (cos(x0))) / (w1=-0.393980)) Loss: 5.51772e-11\n", "\n" ] } ], "source": [ "solution, _, _ = model.fit(X, y, ngenerations=5, nsupergenerations=4, nepochs=500)" ] }, { "cell_type": "markdown", "id": "225e3a3d", "metadata": {}, "source": [ "**Inference**\n", "\n", "It's time to print the best solution." ] }, { "cell_type": "code", "execution_count": 10, "id": "1d948a66", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((((x0) * (x0)) - (w0=0.250004)) - (w0=0.250004)) - (((x0) * (cos(x0))) / (w1=-0.393980))" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "solution" ] }, { "cell_type": "markdown", "id": "69feaf47", "metadata": {}, "source": [ "We can also display what the model prediction looks like, and compare it with the original dataset" ] }, { "cell_type": "code", "execution_count": 12, "id": "e70e7956", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "y_original = y\n", "y_predicted = model.predict(X)\n", "\n", "plt.figure()\n", "plt.scatter(X, y_original, label='Original Dataset')\n", "plt.plot(X, y_predicted, label='Model Prediction')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "6e90ce54", "metadata": {}, "source": [ "We have obtained a nearly perfect fit. It has also discovered the terms $x*x$ and $x*cos(x)$ in the original expression that was used to generate the dataset." ] } ], "metadata": { "kernelspec": { "display_name": ".venv", "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.3" } }, "nbformat": 4, "nbformat_minor": 5 }