pyeggp 1.0.2__cp39-cp39-manylinux_2_28_aarch64.whl → 1.0.4__cp39-cp39-manylinux_2_28_aarch64.whl

pyeggp/__init__.py

@@ -2,6 +2,7 @@ import atexit
 from contextlib import contextmanager
 from threading import Lock
 from typing import Iterator, List
+import string
 from io import StringIO
 import tempfile
 import csv
@@ -20,7 +21,7 @@ from ._binding import (
     unsafe_hs_pyeggp_exit,
 )
 
-VERSION: str = "1.3.0"
+VERSION: str = "1.0.4"
 
 
 _hs_rts_init: bool = False
@@ -58,8 +59,140 @@ def pyeggp_run(dataset: str, gen: int, nPop: int, maxSize: int, nTournament: int
     with hs_rts_init():
         return unsafe_hs_pyeggp_run(dataset, gen, nPop, maxSize, nTournament, pc, pm, nonterminals, loss, optIter, optRepeat, nParams, split, simplify, dumpTo, loadFrom)
 
+def make_function(expression, loss="MSE"):
+    def func(x, t):
+        y = eval(expression)
+        if loss == "Bernoulli":
+            return 1/(1 + np.exp(-y))
+        elif loss == "Poisson":
+            return np.exp(y)
+        return y
+    return func
+
 class PyEGGP(BaseEstimator, RegressorMixin):
+    """ Builds a symbolic regression model using eggp.
+
+    Parameters
+    ----------
+    gen : int, default=100
+        The number of generations.
+
+    nPop : int, default=100
+        Population size.
+
+    maxSize : int, default=15
+        Maximum allowed size for the expression.
+        This should not be larger than 100 as the e-graph may grow
+        too large.
+
+    nTournament : int, default=3
+        Tournament size. During parent selection it will
+        pick `nTournament` expressions at random and
+        return the best among them.
+
+    pc : float, default=0.9
+        Probability of performing the crossover operator.
+
+    pm : float, default=0.3
+        Probability of performing the mutation operator.
+
+    nonterminals : str, default="add,sub,mul,div"
+        String of a comma separated list of nonterminals.
+        These are the allowed functions to be used during the search.
+        Available functions: add,sub,mul,div,power,powerabs,aq,abs,sin,cos,
+                             tan,sinh,cosh,tanh,asin,acos,atan,asinh,acosh,
+                             atanh,sqrt,sqrtabs,cbrt,square,log,logabs,exp,
+                             recip,cube.
+        Where `aq` is the analytical quotient (x/sqrt(1 + y^2)),
+              `powerabs` is the protected power (x^|y|)
+              `sqrtabs` is the protected sqrt (sqrt(|x|))
+              `logabs` is the protected log (log(|x|))
+              `recip` is the reciprocal (1/x)
+              `cbrt` is the cubic root
+
+    loss : {"MSE", "Gaussian", "Bernoulli", "Poisson"}, default="MSE"
+        Loss function used to evaluate the expressions:
+        - MSE (mean squared error) should be used for regression problems.
+        - Gaussian likelihood should be used for regression problem when you want to
+          fit the error term.
+        - Bernoulli likelihood should be used for classification problem.
+        - Poisson likelihood should be used when the data distribution follows a Poisson.
+
+    optIter : int, default=50
+        Number of iterations for the parameter optimization.
+
+    optRepeat : int, default=2
+        Number of restarts for the parameter optimization.
+
+    nParams : int, default=-1
+        Maximum number of parameters. If set to -1 it will
+        allow the expression to have any number of parameters.
+        If set to a number > 0, it will limit the number of parameters,
+        but allow it to appear multiple times in the expression.
+        E.g., t0 * x0 + exp(t0*x0 + t1)
+
+    split : int, default=1
+        How to split the data to create the validation set.
+        If set to 1, it will use the whole data for fitting the parameter and
+        calculating the fitness function.
+        If set to n>1, it will use 1/n for calculating the fitness function
+        and the reminder for fitting the parameter.
+
+    simplify : bool, default=False
+        Whether to apply a final step of equality saturation to simplify the expressions.
+
+    dumpTo : str, default=""
+        If not empty, it will save the final e-graph into the filename.
+
+    loadFrom : str, default=""
+        If not empty, it will load an e-graph and resume the search.
+        The user must ensure that the loaded e-graph is from the same
+        dataset and loss function.
+
+    Examples
+    --------
+    >>> from pyeggp import PyEGGP
+    >>> import numpy as np
+    >>> X = np.arange(100).reshape(100, 1)
+    >>> y = np.zeros((100, ))
+    >>> estimator = PyEGGP()
+    >>> estimator.fit(X, y)
+    >>>
+    >>> estimator = PyEGGP(loss="Bernoulli")
+    >>> estimator.fit(X, y)
+    """
     def __init__(self, gen = 100, nPop = 100, maxSize = 15, nTournament = 3, pc = 0.9, pm = 0.3, nonterminals = "add,sub,mul,div", loss = "MSE", optIter = 50, optRepeat = 2, nParams = -1, split = 1, simplify = False, dumpTo = "", loadFrom = ""):
+        nts = "add,sub,mul,div,power,powerabs,\
+               aq,abs,sin,cos,tan,sinh,cosh,tanh,\
+               asin,acos,atan,asinh,acosh,atanh,sqrt,\
+               sqrtabs,cbrt,square,log,logabs,exp,recip,cube"
+        losses = ["MSE", "Gaussian", "Bernoulli", "Poisson"]
+        if gen < 1:
+            raise ValueError('gen should be greater than 1')
+        if nPop < 1:
+            raise ValueError('nPop should be greater than 1')
+        if maxSize < 1 or maxSize > 100:
+            raise ValueError('maxSize should be a value between 1 and 100')
+        if nTournament < 1 or nTournament > nPop:
+            raise ValueError('nTournament should be a value between 1 and nPop')
+        if pc < 0 or pc > 1:
+            raise ValueError('pc should be between 0 and 1')
+        if pm < 0 or pm > 1:
+            raise ValueError('pm should be between 0 and 1')
+        if any(t not in nts for t in nonterminals):
+            raise ValueError('nonterminals must be a comma separated list of one or more of ', nts)
+        if loss not in losses:
+            raise ValueError('loss must be one of ', losses)
+        if optIter < 0:
+            raise ValueError('optIter must be a positive number')
+        if optRepeat < 0:
+            raise ValueError('optRepeat must be a positive number')
+        if nParams < -1:
+            raise ValueError('nParams must be either -1 or a positive number')
+        if split < 1:
+            raise ValueError('split must be equal or greater than 1')
+        if not isinstance(simplify, bool):
+            raise TypeError('simplify must be a boolean')
         self.gen = gen
         self.nPop = nPop
         self.maxSize = maxSize
@@ -78,6 +211,15 @@ class PyEGGP(BaseEstimator, RegressorMixin):
         self.is_fitted_ = False
 
     def fit(self, X, y):
+        ''' Fits the regression model.
+
+        Parameters
+        ----------
+        X : np.array
+            An m x n np.array describing m observations of n features.
+        y : np.array
+            An np.array of size m with the measured target values.
+        '''
         if X.ndim == 1:
             X = X.reshape(-1,1)
         y = y.reshape(-1, 1)
@@ -97,6 +239,15 @@ class PyEGGP(BaseEstimator, RegressorMixin):
         return self
 
     def fit_mvsr(self, Xs, ys):
+        ''' Fits a multi-view regression model.
+
+        Parameters
+        ----------
+        Xs : list(np.array)
+            A list with k elements of m_k x n np.arrays describing m_k observations of n features.
+        ys : list(np.array)
+            A list of k elements of np.arrays of size m_k with the measured target values.
+        '''
         if Xs[0].ndim == 1:
             Xs = [X.reshape(-1,1) for X in Xs]
         ys = [y.reshape(-1, 1) for y in ys]
@@ -118,10 +269,43 @@ class PyEGGP(BaseEstimator, RegressorMixin):
         return self
 
     def predict(self, X):
+        ''' Generates the prediction using the best model (selected by accuracy)
+
+        Parameters
+        ----------
+        X : np.array
+            An m x n np.array describing m observations of n features.
+            This array must have the same number of features as the training data.
+
+        Return
+        ------
+        y : np.array
+            A vector of predictions
+
+        A table with the fitted models and additional information
+        will be stored as a Pandas dataframe in self.results.
+        '''
         check_is_fitted(self)
         return self.evaluate_best_model(X)
 
     def predict_mvsr(self, X, view):
+        ''' Generates the prediction using the best model (selected by accuracy)
+            of the sepecified `view`
+
+        Parameters
+        ----------
+        X : np.array
+            An m x n np.array describing m observations of n features.
+            This array must have the same number of features as the training data.
+
+        view : int
+            The index of the view (starting at 0).
+
+        Return
+        ------
+        y : np.array
+            A vector of predictions
+        '''
         check_is_fitted(self)
         return self.evaluate_best_model_view(X, view)
 
@@ -129,26 +313,65 @@ class PyEGGP(BaseEstimator, RegressorMixin):
         if x.ndim == 1:
             x = x.reshape(-1,1)
         t = np.array(list(map(float, self.results.iloc[-1].theta.split(";"))))
-        return eval(self.results.iloc[-1].Numpy)
+        y = eval(self.results.iloc[-1].Numpy)
+        if self.loss == "Bernoulli":
+            return 1/(1 + np.exp(-y))
+        elif self.loss == "Poisson":
+            return np.exp(y)
+        return y
     def evaluate_best_model_view(self, x, view):
         if x.ndim == 1:
             x = x.reshape(-1,1)
         ix = self.results.iloc[-1].id
         best = self.results[self.results.id==ix].iloc[view]
         t = np.array(list(map(float, best.theta.split(";"))))
-        return eval(best.Numpy)
+        y = eval(best.Numpy)
+        if self.loss == "Bernoulli":
+            return 1/(1 + np.exp(-y))
+        elif self.loss == "Poisson":
+            return np.exp(y)
+        return y
 
     def evaluate_model_view(self, x, ix, view):
         if x.ndim == 1:
             x = x.reshape(-1,1)
         best = self.results[self.results.id==ix].iloc[view]
         t = np.array(list(map(float, best.theta.split(";"))))
-        return eval(best.Numpy)
+        y = eval(best.Numpy)
+        if self.loss == "Bernoulli":
+            return 1/(1 + np.exp(-y))
+        elif self.loss == "Poisson":
+            return np.exp(y)
+        return y
     def evaluate_model(self, ix, x):
         if x.ndim == 1:
             x = x.reshape(-1,1)
         t = np.array(list(map(float, self.results.iloc[-1].theta.split(";"))))
-        return eval(self.results.iloc[i].Numpy)
+        y = eval(self.results.iloc[i].Numpy)
+        if self.loss == "Bernoulli":
+            return 1/(1 + np.exp(-y))
+        elif self.loss == "Poisson":
+            return np.exp(y)
+        return y
     def score(self, X, y):
+        ''' Calculates the score (single-view only).
+        '''
         ypred = self.evaluate_best_model(X)
         return r2_score(y, ypred)
+    def get_model(self, idx):
+        ''' Get a `model` function and its visual representation. '''
+        alphabet = list(string.ascii_uppercase)
+        row = self.results[self.results['id']==idx].iloc[0]
+        visual_expression = row['Numpy']
+        model = make_function(visual_expression, self.loss)
+        n_params_used = len(row['theta'].split(sep=';'))
+    
+        # Works for solutions with less than 26 parameters
+        for i in range(n_params_used):
+            visual_expression = visual_expression.replace(f't[{i}]', alphabet[i])
+    
+        # Works for data with less than 50 dimensions
+        for i in range(50):
+            visual_expression = visual_expression.replace(f'x[:, {i}]', f'X{i}')
+    
+        return model, visual_expression

{pyeggp-1.0.2.dist-info → pyeggp-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyeggp
-Version: 1.0.2
+Version: 1.0.4
 Summary: Python Wheels for eggp algorithm.
 Author-email: Fabricio Olivetti <folivetti@users.noreply.github.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -695,16 +695,181 @@ Provides-Extra: mypy
 Requires-Dist: types_setuptools>=45; extra == "mypy"
 Dynamic: license-file
 
-# pyeggp - Python e-graph GP
+# PyEGGP
 
-Python bindings for [eggp](https://github.com/folivetti/srtree/blob/main/apps/eggp/README.md).
+A Python package for symbolic regression using e-graph-based genetic programming. PyEGGP provides a scikit-learn compatible API for evolutionary symbolic regression tasks.
 
-ggp (e-graph genetic programming), follows the same structure as the traditional GP. The initial population is created using ramped half-and-half respecting a maximum size and maximum depth parameter and, for a number of generations, it will choose two parents using tournament selection, apply the subtree crossover with probability $pc$  followed by the subtree mutation with probability $pm$, when the offsprings replace the current population following a dominance criteria.
+More info [here](https://github.com/folivetti/srtree/tree/main/apps/eggp)
 
-How to install the package:
+## Installation
 
 ```bash
 pip install pyeggp
 ```
 
+## Features
+
+- Scikit-learn compatible API with `fit()` and `predict()` methods
+- Genetic programming approach with e-graph representation
+- Support for **multi-view symbolic regression** [see here](https://arxiv.org/abs/2402.04298)
+- Customizable evolutionary parameters (population size, tournament selection, etc.)
+- Flexible function set selection
+- Various loss functions for different problem types
+- Parameter optimization with multiple restarts
+- Optional expression simplification through equality saturation
+- Ability to save and load e-graphs
+
+## Usage
+
+### Basic Example
+
+```python
+from pyeggp import PyEGGP
+import numpy as np
+
+# Create sample data
+X = np.linspace(-10, 10, 100).reshape(-1, 1)
+y = 2 * X.ravel() + 3 * np.sin(X.ravel()) + np.random.normal(0, 1, 100)
+
+# Create and fit the model
+model = PyEGGP(gen=100, nonterminals="add,sub,mul,div,sin,cos")
+model.fit(X, y)
+
+# Make predictions
+y_pred = model.predict(X)
+
+# Examine the results
+print(model.results)
+```
+
+### Multi-View Symbolic Regression
+
+```python
+from pyeggp import PyEGGP
+import numpy as np
+
+# Create multiple views of data
+X1 = np.linspace(-5, 5, 50).reshape(-1, 1)
+y1 = np.sin(X1.ravel()) + np.random.normal(0, 0.1, 50)
+
+X2 = np.linspace(0, 10, 100).reshape(-1, 1)
+y2 = np.sin(X2.ravel()) + np.random.normal(0, 0.2, 100)
+
+# Create and fit multi-view model
+model = PyEGGP(gen=150, nPop=200)
+model.fit_mvsr([X1, X2], [y1, y2])
+
+# Make predictions for each view
+y_pred1 = model.predict_mvsr(X1, view=0)
+y_pred2 = model.predict_mvsr(X2, view=1)
+```
+
+### Integration with scikit-learn
+
+```python
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+from pyeggp import PyEGGP
+
+# Split data
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
+
+# Create and fit model
+model = PyEGGP(gen=150, nPop=150, optIter=100)
+model.fit(X_train, y_train)
+
+# Evaluate on test set
+y_pred = model.predict(X_test)
+mse = mean_squared_error(y_test, y_pred)
+print(f"Test MSE: {mse}")
+```
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `gen` | int | 100 | Number of generations to run |
+| `nPop` | int | 100 | Population size |
+| `maxSize` | int | 15 | Maximum allowed size for expressions (max 100) |
+| `nTournament` | int | 3 | Tournament size for parent selection |
+| `pc` | float | 0.9 | Probability of performing crossover |
+| `pm` | float | 0.3 | Probability of performing mutation |
+| `nonterminals` | str | "add,sub,mul,div" | Comma-separated list of allowed functions |
+| `loss` | str | "MSE" | Loss function: "MSE", "Gaussian", "Bernoulli", or "Poisson" |
+| `optIter` | int | 50 | Number of iterations for parameter optimization |
+| `optRepeat` | int | 2 | Number of restarts for parameter optimization |
+| `nParams` | int | -1 | Maximum number of parameters (-1 for unlimited) |
+| `split` | int | 1 | Data splitting ratio for validation |
+| `simplify` | bool | False | Whether to apply equality saturation to simplify expressions |
+| `dumpTo` | str | "" | Filename to save the final e-graph |
+| `loadFrom` | str | "" | Filename to load an e-graph to resume search |
+
+## Available Functions
+
+The following functions can be used in the `nonterminals` parameter:
+
+- Basic operations: `add`, `sub`, `mul`, `div`
+- Powers: `power`, `powerabs`, `square`, `cube`
+- Roots: `sqrt`, `sqrtabs`, `cbrt`
+- Trigonometric: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`
+- Hyperbolic: `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`
+- Others: `abs`, `log`, `logabs`, `exp`, `recip`, `aq` (analytical quotient)
+
+## Methods
+
+### Core Methods
+- `fit(X, y)`: Fits the symbolic regression model
+- `predict(X)`: Generates predictions using the best model
+- `score(X, y)`: Computes R² score of the best model
+
+### Multi-View Methods
+- `fit_mvsr(Xs, ys)`: Fits a multi-view regression model
+- `predict_mvsr(X, view)`: Generates predictions for a specific view
+- `evaluate_best_model_view(X, view)`: Evaluates the best model on a specific view
+- `evaluate_model_view(X, ix, view)`: Evaluates a specific model on a specific view
+
+### Utility Methods
+- `evaluate_best_model(X)`: Evaluates the best model on the given data
+- `evaluate_model(ix, X)`: Evaluates the model with index `ix` on the given data
+- `get_model(idx)`: Returns a model function and its visual representation
+
+## Results
+
+After fitting, the `results` attribute contains a pandas DataFrame with details about the discovered models, including:
+- Mathematical expressions
+- Model complexity
+- Parameter values
+- Error metrics
+- NumPy-compatible expressions
+
+## License
+
+[LICENSE]
+
+## Citation
+
+If you use PyEGGP in your research, please cite:
+
+```
+@inproceedings{eggp,
+author = {de Franca, Fabricio Olivetti and Kronberger, Gabriel},
+title = {Improving Genetic Programming for Symbolic Regression with Equality Graphs},
+year = {2025},
+isbn = {9798400714658},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3712256.3726383},
+doi = {10.1145/3712256.3726383},
+booktitle = {Proceedings of the Genetic and Evolutionary Computation Conference},
+pages = {},
+numpages = {9},
+keywords = {Symbolic regression, Genetic programming, Equality saturation, Equality graphs},
+location = {Malaga, Spain},
+series = {GECCO '25},
+archivePrefix = {arXiv},
+       eprint = {2501.17848},
+ primaryClass = {cs.LG}, 
+}
+```
+
 The bindings were created following the amazing example written by [wenkokke](https://github.com/wenkokke/example-haskell-wheel)

{pyeggp-1.0.2.dist-info → pyeggp-1.0.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-pyeggp/__init__.py,sha256=ag29g10K_goyZDXVPc-QeT5M332KN1mddYZ-FaEGlgQ,5775
+pyeggp/__init__.py,sha256=QgE_I_04eCrMWgFJ05Qk7yE0aCYVMrx9Ayu4B01ns2A,14290
 pyeggp/__main__.py,sha256=dAMEebAw-mVcR5PUffuRsUDPFm6Vf4qvaam9TPSUs0I,155
-pyeggp/_binding.cpython-39-aarch64-linux-gnu.so,sha256=fuEGloy8T_YHO-x01wDIuev8x2y_4XTwBMTlFpkFPlE,1016193
+pyeggp/_binding.cpython-39-aarch64-linux-gnu.so,sha256=SHh5sYa377pOqNrTX8wj2bYlMxTADSHrq29mHL0189U,1016193
 pyeggp/_binding.py,sha256=ELhOPKnGQU2tLdcv38iaqHbKrr4_ha7GztqghAOz4us,590
 pyeggp/_binding.pyi,sha256=TsI8Gar1wpDs3c8V26i3w_u1JjznlE5dReV59bbVUh0,460
 pyeggp/binding.i,sha256=AdPEymjqByW6OhpJS08o2oTc7Go3-274JqRhbXoyDjg,1908
@@ -118,9 +118,9 @@ pyeggp./libHSzlib-0-48ee1f9e.7.1.0-5585aebc199b08d8e21b5678c0fd28335affe6252f546
 pyeggp./libffi-c0132414.so.8,sha256=oTvjWevsiUzLHfgJ-ZZLqC1CD1h0cC6biH2mE8iWFuE,132737
 pyeggp./libgmp-6d1678ee.so.10.3.2,sha256=K-WFYhW6C3Z3ecUJJps22sV11vBCXEVqIP5tzap4xyg,605705
 pyeggp./libnlopt-38a103cb.so.0,sha256=SoGgo4hNv89sqJRH5RWvp21cEoJFfQCkLSkVTBynEp8,738297
-pyeggp-1.0.2.dist-info/METADATA,sha256=ezRmsnPEc0Uc8Coi_5xX08en30lyJdV0PKk8gT2njvc,42220
-pyeggp-1.0.2.dist-info/WHEEL,sha256=unRpbOfgxFDYN2_eraHEgv-PNJibz-3dg9hYHo22NBw,112
-pyeggp-1.0.2.dist-info/entry_points.txt,sha256=NJouaQ2UoCLBu7Toqer0FBvNSDYMawR_Wx9STMdopyY,48
-pyeggp-1.0.2.dist-info/top_level.txt,sha256=iLrWfWZHh4NruYDgVyn2ntEB-uJ8fIs95nzNVLIhKE4,7
-pyeggp-1.0.2.dist-info/RECORD,,
-pyeggp-1.0.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pyeggp-1.0.4.dist-info/METADATA,sha256=N-PYOBXBRTwH2WHrlFl4T1uoHHsFYUUy9UJjmCW3zeg,47258
+pyeggp-1.0.4.dist-info/WHEEL,sha256=xu7dZsJsMqZvsykkofGwNru5jINOJxejClPf6RzTQhQ,112
+pyeggp-1.0.4.dist-info/entry_points.txt,sha256=NJouaQ2UoCLBu7Toqer0FBvNSDYMawR_Wx9STMdopyY,48
+pyeggp-1.0.4.dist-info/top_level.txt,sha256=iLrWfWZHh4NruYDgVyn2ntEB-uJ8fIs95nzNVLIhKE4,7
+pyeggp-1.0.4.dist-info/RECORD,,
+pyeggp-1.0.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149

{pyeggp-1.0.2.dist-info → pyeggp-1.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: false
 Tag: cp39-cp39-manylinux_2_28_aarch64