pyeggp 1.0.3__tar.gz → 1.0.4__tar.gz

{pyeggp-1.0.3 → pyeggp-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyeggp
-Version: 1.0.3
+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.4/README.md

@@ -0,0 +1,178 @@
+# PyEGGP
+
+A Python package for symbolic regression using e-graph-based genetic programming. PyEGGP provides a scikit-learn compatible API for evolutionary symbolic regression tasks.
+
+More info [here](https://github.com/folivetti/srtree/tree/main/apps/eggp)
+
+## 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.3 → pyeggp-1.0.4}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyeggp"
-version = "1.0.3"
+version = "1.0.4"
 authors = [{ name = "Fabricio Olivetti", email = "folivetti@users.noreply.github.com" }]
 description = "Python Wheels for eggp algorithm."
 readme = "README.md"

pyeggp-1.0.4/src/pyeggp/__init__.py

@@ -0,0 +1,377 @@
+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
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, RegressorMixin
+from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
+from sklearn.metrics import mean_squared_error, r2_score
+
+from ._binding import (
+    unsafe_hs_pyeggp_version,
+    unsafe_hs_pyeggp_main,
+    unsafe_hs_pyeggp_run,
+    unsafe_hs_pyeggp_init,
+    unsafe_hs_pyeggp_exit,
+)
+
+VERSION: str = "1.0.4"
+
+
+_hs_rts_init: bool = False
+_hs_rts_lock: Lock = Lock()
+
+
+def hs_rts_exit() -> None:
+    global _hs_rts_lock
+    with _hs_rts_lock:
+        unsafe_hs_pyeggp_exit()
+
+
+@contextmanager
+def hs_rts_init(args: List[str] = []) -> Iterator[None]:
+    global _hs_rts_init
+    global _hs_rts_lock
+    with _hs_rts_lock:
+        if not _hs_rts_init:
+            _hs_rts_init = True
+            unsafe_hs_pyeggp_init(args)
+            atexit.register(hs_rts_exit)
+    yield None
+
+
+def version() -> str:
+    with hs_rts_init():
+        return unsafe_hs_pyeggp_version()
+
+
+def main(args: List[str] = []) -> int:
+    with hs_rts_init(args):
+        return unsafe_hs_pyeggp_main()
+
+def pyeggp_run(dataset: str, gen: int, nPop: int, maxSize: int, nTournament: int, pc: float, pm: float, nonterminals: str, loss: str, optIter: int, optRepeat: int, nParams: int, split: int, simplify: int, dumpTo: str, loadFrom: str) -> str:
+    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
+        self.nTournament = nTournament
+        self.pc = pc
+        self.pm = pm
+        self.nonterminals = nonterminals
+        self.loss = loss
+        self.optIter = optIter
+        self.optRepeat = optRepeat
+        self.nParams = nParams
+        self.split = split
+        self.simplify = int(simplify)
+        self.dumpTo = dumpTo
+        self.loadFrom = loadFrom
+        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)
+        combined = np.hstack([X, y])
+        header = [f"x{i}" for i in range(X.shape[1])] + ["y"]
+        with tempfile.NamedTemporaryFile(mode='w+', newline='', delete=False, suffix='.csv') as temp_file:
+            writer = csv.writer(temp_file)
+            writer.writerow(header)
+            writer.writerows(combined)
+            dataset = temp_file.name
+
+        csv_data = pyeggp_run(dataset, self.gen, self.nPop, self.maxSize, self.nTournament, self.pc, self.pm, self.nonterminals, self.loss, self.optIter, self.optRepeat, self.nParams, self.split, self.simplify, self.dumpTo, self.loadFrom)
+        if len(csv_data) > 0:
+            csv_io = StringIO(csv_data.strip())
+            self.results = pd.read_csv(csv_io, header=0)
+            self.is_fitted_ = True
+        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]
+        combineds = [np.hstack([X, y]) for X, y in zip(Xs, ys)]
+        header = [f"x{i}" for i in range(Xs[0].shape[1])] + ["y"]
+        datasets = []
+        for combined in combineds:
+            with tempfile.NamedTemporaryFile(mode='w+', newline='', delete=False, suffix='.csv') as temp_file:
+                writer = csv.writer(temp_file)
+                writer.writerow(header)
+                writer.writerows(combined)
+                datasets.append(temp_file.name)
+
+        csv_data = pyeggp_run(" ".join(datasets), self.gen, self.nPop, self.maxSize, self.nTournament, self.pc, self.pm, self.nonterminals, self.loss, self.optIter, self.optRepeat, self.nParams, self.split, self.simplify, self.dumpTo, self.loadFrom)
+        if len(csv_data) > 0:
+            csv_io = StringIO(csv_data.strip())
+            self.results = pd.read_csv(csv_io, header=0, dtype={'theta':str})
+            self.is_fitted_ = True
+        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)
+
+    def evaluate_best_model(self, x):
+        if x.ndim == 1:
+            x = x.reshape(-1,1)
+        t = np.array(list(map(float, self.results.iloc[-1].theta.split(";"))))
+        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(";"))))
+        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(";"))))
+        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(";"))))
+        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.3 → pyeggp-1.0.4}/src/pyeggp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyeggp
-Version: 1.0.3
+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.3 → pyeggp-1.0.4}/test/test_pyeggp.py

@@ -15,7 +15,7 @@ Z = df.values
 X = Z[:,:-1]
 y = Z[:,-1]
 
-reg = PyEGGP(100, 100, 10, 3, 0.9, 0.3, "add,sub,mul,div,log", "MSE", 50, 2, -1, 3, 0, "", "")
+reg = PyEGGP(100, 100, 10, 3, 0.9, 0.3, "add,sub,mul,div,log", "MSE", 50, 2, -1, 3, True, "", "")
 reg.fit(X, y)
 print(reg.score(X, y))
 

pyeggp-1.0.3/README.md

@@ -1,13 +0,0 @@
-# pyeggp - Python e-graph GP
-
-Python bindings for [eggp](https://github.com/folivetti/srtree/blob/main/apps/eggp/README.md).
-
-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.
-
-How to install the package:
-
-```bash
-pip install pyeggp
-```
-
-The bindings were created following the amazing example written by [wenkokke](https://github.com/wenkokke/example-haskell-wheel)

pyeggp-1.0.3/src/pyeggp/__init__.py

@@ -1,176 +0,0 @@
-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
-
-import numpy as np
-import pandas as pd
-from sklearn.base import BaseEstimator, RegressorMixin
-from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
-from sklearn.metrics import mean_squared_error, r2_score
-
-from ._binding import (
-    unsafe_hs_pyeggp_version,
-    unsafe_hs_pyeggp_main,
-    unsafe_hs_pyeggp_run,
-    unsafe_hs_pyeggp_init,
-    unsafe_hs_pyeggp_exit,
-)
-
-VERSION: str = "1.3.0"
-
-
-_hs_rts_init: bool = False
-_hs_rts_lock: Lock = Lock()
-
-
-def hs_rts_exit() -> None:
-    global _hs_rts_lock
-    with _hs_rts_lock:
-        unsafe_hs_pyeggp_exit()
-
-
-@contextmanager
-def hs_rts_init(args: List[str] = []) -> Iterator[None]:
-    global _hs_rts_init
-    global _hs_rts_lock
-    with _hs_rts_lock:
-        if not _hs_rts_init:
-            _hs_rts_init = True
-            unsafe_hs_pyeggp_init(args)
-            atexit.register(hs_rts_exit)
-    yield None
-
-
-def version() -> str:
-    with hs_rts_init():
-        return unsafe_hs_pyeggp_version()
-
-
-def main(args: List[str] = []) -> int:
-    with hs_rts_init(args):
-        return unsafe_hs_pyeggp_main()
-
-def pyeggp_run(dataset: str, gen: int, nPop: int, maxSize: int, nTournament: int, pc: float, pm: float, nonterminals: str, loss: str, optIter: int, optRepeat: int, nParams: int, split: int, simplify: int, dumpTo: str, loadFrom: str) -> str:
-    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):
-    def func(x, t):
-        return eval(expression)
-    return func
-
-class PyEGGP(BaseEstimator, RegressorMixin):
-    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 = ""):
-        self.gen = gen
-        self.nPop = nPop
-        self.maxSize = maxSize
-        self.nTournament = nTournament
-        self.pc = pc
-        self.pm = pm
-        self.nonterminals = nonterminals
-        self.loss = loss
-        self.optIter = optIter
-        self.optRepeat = optRepeat
-        self.nParams = nParams
-        self.split = split
-        self.simplify = int(simplify)
-        self.dumpTo = dumpTo
-        self.loadFrom = loadFrom
-        self.is_fitted_ = False
-
-    def fit(self, X, y):
-        if X.ndim == 1:
-            X = X.reshape(-1,1)
-        y = y.reshape(-1, 1)
-        combined = np.hstack([X, y])
-        header = [f"x{i}" for i in range(X.shape[1])] + ["y"]
-        with tempfile.NamedTemporaryFile(mode='w+', newline='', delete=False, suffix='.csv') as temp_file:
-            writer = csv.writer(temp_file)
-            writer.writerow(header)
-            writer.writerows(combined)
-            dataset = temp_file.name
-
-        csv_data = pyeggp_run(dataset, self.gen, self.nPop, self.maxSize, self.nTournament, self.pc, self.pm, self.nonterminals, self.loss, self.optIter, self.optRepeat, self.nParams, self.split, self.simplify, self.dumpTo, self.loadFrom)
-        if len(csv_data) > 0:
-            csv_io = StringIO(csv_data.strip())
-            self.results = pd.read_csv(csv_io, header=0)
-            self.is_fitted_ = True
-        return self
-
-    def fit_mvsr(self, Xs, ys):
-        if Xs[0].ndim == 1:
-            Xs = [X.reshape(-1,1) for X in Xs]
-        ys = [y.reshape(-1, 1) for y in ys]
-        combineds = [np.hstack([X, y]) for X, y in zip(Xs, ys)]
-        header = [f"x{i}" for i in range(Xs[0].shape[1])] + ["y"]
-        datasets = []
-        for combined in combineds:
-            with tempfile.NamedTemporaryFile(mode='w+', newline='', delete=False, suffix='.csv') as temp_file:
-                writer = csv.writer(temp_file)
-                writer.writerow(header)
-                writer.writerows(combined)
-                datasets.append(temp_file.name)
-
-        csv_data = pyeggp_run(" ".join(datasets), self.gen, self.nPop, self.maxSize, self.nTournament, self.pc, self.pm, self.nonterminals, self.loss, self.optIter, self.optRepeat, self.nParams, self.split, self.simplify, self.dumpTo, self.loadFrom)
-        if len(csv_data) > 0:
-            csv_io = StringIO(csv_data.strip())
-            self.results = pd.read_csv(csv_io, header=0, dtype={'theta':str})
-            self.is_fitted_ = True
-        return self
-
-    def predict(self, X):
-        check_is_fitted(self)
-        return self.evaluate_best_model(X)
-
-    def predict_mvsr(self, X, view):
-        check_is_fitted(self)
-        return self.evaluate_best_model_view(X, view)
-
-    def evaluate_best_model(self, 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[-1].Numpy)
-    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)
-
-    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)
-    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)
-    def score(self, X, y):
-        ypred = self.evaluate_best_model(X)
-        return r2_score(y, ypred)
-    def get_model(self, idx):
-        alphabet = list(string.ascii_uppercase)
-        row = self.results[self.results['id']==idx].iloc[0]
-        visual_expression = row['Numpy']
-        model = make_function(visual_expression)
-        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