Merge pull request #87 from MilesCranmer/pyjulia

.github/workflows/CI.yml

@@ -61,6 +61,7 @@ jobs:
             python -m pip install --upgrade pip
             pip install -r requirements.txt
             python setup.py install
+            python -c 'import pysr; pysr.install()'
       - name: "Install Coverage tool"
         run: pip install coverage coveralls
       - name: "Run tests"

.github/workflows/CI_Windows.yml

@@ -61,6 +61,7 @@ jobs:
             python -m pip install --upgrade pip
             pip install -r requirements.txt
             python setup.py install
+            python -c 'import pysr; pysr.install()'
       - name: "Run tests"
         run: python -m unittest test.test
         shell: bash

.github/workflows/CI_conda.yml

@@ -0,0 +1,76 @@
+name: CI_conda
+# This tests whether conda, a statically-linked libpython, works
+# with PySR.
+
+on:
+  push:
+    branches:
+      - '*'
+    paths:
+      - 'test/**'
+      - 'pysr/**'
+      - '.github/workflows/**'
+      - 'setup.py'
+      - 'Project.toml'
+  pull_request:
+    branches:
+      - '*'
+    paths:
+      - 'test/**'
+      - 'pysr/**'
+      - '.github/workflows/**'
+      - 'setup.py'
+      - 'Project.toml'
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: ['1.7.1']
+        python-version: ['3.9']
+        os: ['ubuntu-latest']
+    
+    steps:
+      - uses: actions/checkout@v1.0.0
+      - name: "Set up Julia"
+        uses: julia-actions/setup-julia@v1.6.0
+        with:
+          version: ${{ matrix.julia-version }}
+      - name: "Change package server"
+        shell: bash
+        env:
+            JULIA_PKG_SERVER: ""
+        run: |
+            julia -e 'using Pkg; Pkg.Registry.add("General")'
+      - name: "Cache dependencies"
+        uses: actions/cache@v1 # Thanks FromFile.jl
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+      - name: "Set up Conda"
+        uses: conda-incubator/setup-miniconda@v2
+        with:
+          miniforge-variant: Mambaforge
+          miniforge-version: latest
+          auto-activate-base: true
+          python-version: ${{ matrix.python-version }}
+          activate-environment: test
+          environment-file: environment.yml
+      - name: "Install PySR"
+        run: |
+            python3 -m pip install .
+            python3 -c 'import pysr; pysr.install()'
+        shell: bash -l {0}
+      - name: "Ensure that static libpython warning appears"
+        run: python3 test/test_static_libpython_warning.py
+        shell: bash -l {0}
+      - name: "Run tests"
+        run: python3 -m unittest test.test
+        shell: bash -l {0}

.github/workflows/CI_mac.yml

@@ -61,6 +61,7 @@ jobs:
             python -m pip install --upgrade pip
             pip install -r requirements.txt
             python setup.py install
+            python -c 'import pysr; pysr.install()'
       - name: "Run tests"
         run: python -m unittest test.test
         shell: bash

.gitignore

@@ -12,3 +12,6 @@ dist
 *.pyproj
 *.sln
 pysr/.vs/
+pysr.egg-info
+Manifest.toml
+workflow

Dockerfile

@@ -1,30 +1,44 @@
 # This builds a dockerfile containing a working copy of PySR
 # with all pre-requisites installed.
 
-
 ARG VERSION=latest
+
 FROM julia:$VERSION
 
 RUN apt-get update && apt-get upgrade -y && apt-get install -y \
-    build-essential python3 python3-dev python3-pip python3-setuptools \
-    vim git wget curl \
+    make build-essential libssl-dev zlib1g-dev \
+    libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm \
+    libncursesw5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev \
+    vim git \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /pysr
 
+# Install PyEnv to switch Python to dynamically linked version:
+RUN curl https://pyenv.run | bash
+ENV PATH="/root/.pyenv/bin:$PATH"
+
+ENV PYTHON_VERSION="3.9.10"
+RUN PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install ${PYTHON_VERSION}
+ENV PATH="/root/.pyenv/versions/${PYTHON_VERSION}/bin:$PATH"
+
+# Install IPython and other useful libraries:
+RUN pip install ipython jupyter matplotlib
+
 # Caches install (https://stackoverflow.com/questions/25305788/how-to-avoid-reinstalling-packages-when-building-docker-image-for-python-project)
 ADD ./requirements.txt /pysr/requirements.txt
 RUN pip3 install -r /pysr/requirements.txt
 
 # Install PySR:
-ADD . /pysr/
+# We do a minimal copy so it doesn't need to rerun at every file change:
+ADD ./setup.py /pysr/setup.py
+ADD ./README.md /pysr/README.md
+Add ./Project.toml /pysr/Project.toml
+ADD ./pysr/ /pysr/pysr/
 RUN pip3 install .
 
 # Install Julia pre-requisites:
-RUN julia -e 'using Pkg; Pkg.add("SymbolicRegression")'
-
-# Install IPython and other useful libraries:
-RUN pip3 install ipython jupyter matplotlib
+RUN python3 -c 'import pysr; pysr.install()'
 
-CMD ["bash"]
+CMD ["bash"]

Project.toml

@@ -2,5 +2,5 @@
 SymbolicRegression = "8254be44-1295-4e6a-a16d-46603ac705cb"
 
 [compat]
-SymbolicRegression = "0.6.10"
+SymbolicRegression = "0.6.18"
 julia = "1.5"

README.md

@@ -62,11 +62,14 @@ and [linux](https://julialang.org/downloads/platform/#linux_and_freebsd).
 
 You can install PySR with:
 ```bash
-pip install pysr
+pip3 install pysr
+python3 -c 'import pysr; pysr.install()'
 ```
+The second line will install and update the required Julia packages, including
+`PyCall.jl`.
 
-The first launch will automatically install the Julia packages
-required. Most common issues at this stage are solved
+
+Most common issues at this stage are solved
 by [tweaking the Julia package server](https://github.com/MilesCranmer/PySR/issues/27).
 to use up-to-date packages.
 
@@ -121,6 +124,10 @@ which gives:
 x0**2 + 2.000016*cos(x3) - 1.9999845
 ```
 
+The second and additional calls of `pysr` will be significantly
+faster in startup time, since the first call to Julia will compile
+and cache functions from the symbolic regression backend.
+
 One can also use `best_tex` to get the LaTeX form,
 or `best_callable` to get a function you can call.
 This uses a score which balances complexity and error;

docs/start.md

@@ -7,20 +7,14 @@ Install Julia - see [downloads](https://julialang.org/downloads/), and
 then instructions for [mac](https://julialang.org/downloads/platform/#macos)
 and [linux](https://julialang.org/downloads/platform/#linux_and_freebsd).
 (Don't use the `conda-forge` version; it doesn't seem to work properly.)
-Then, at the command line,
-install the `Optim` and `SpecialFunctions` packages via:
 
+You can install PySR with:
 ```bash
-julia -e 'import Pkg; Pkg.add("Optim"); Pkg.add("SpecialFunctions")'
-```
-
-For python, you need to have Python 3, numpy, sympy, and pandas installed.
-
-You can install this package from PyPI with:
-
-```bash
-pip install pysr
+pip3 install pysr
+python3 -c 'import pysr; pysr.install()'
 ```
+The second line will install and update the required Julia packages, including
+`PyCall.jl`.
 
 ## Quickstart
 
@@ -48,6 +42,10 @@ which gives:
 x0**2 + 2.000016*cos(x3) - 1.9999845
 ```
 
+The second and additional calls of `pysr` will be significantly
+faster in startup time, since the first call to Julia will compile
+and cache functions from the symbolic regression backend.
+
 One can also use `best_tex` to get the LaTeX form,
 or `best_callable` to get a function you can call.
 This uses a score which balances complexity and error;

environment.yml

@@ -0,0 +1,13 @@
+name: test
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - sympy
+  - pandas
+  - numpy
+  - scikit-learn
+  - setuptools
+  - pip
+  - pip:
+    - julia

pysr/__init__.py

@@ -1,4 +1,13 @@
-from .sr import pysr, get_hof, best, best_tex, best_callable, best_row
+from .sr import (
+    pysr,
+    get_hof,
+    best,
+    best_tex,
+    best_callable,
+    best_row,
+    install,
+    silence_julia_warning,
+)
 from .feynman_problems import Problem, FeynmanProblem
 from .export_jax import sympy2jax
 from .export_torch import sympy2torch

pysr/feynman_problems.py

@@ -1,6 +1,5 @@
 import numpy as np
 import csv
-import traceback
 from .sr import pysr, best
 from pathlib import Path
 from functools import partial
@@ -80,20 +79,14 @@ def mk_problems(first=100, gen=False, dp=500, data_dir=FEYNMAN_DATASET):
     """
     ret = []
     with open(data_dir) as csvfile:
-        ind = 0
         reader = csv.DictReader(csvfile)
         for i, row in enumerate(reader):
-            if ind > first:
+            if i > first:
                 break
             if row["Filename"] == "":
                 continue
-            try:
-                p = FeynmanProblem(row, gen=gen, dp=dp)
-                ret.append(p)
-            except Exception as e:
-                traceback.print_exc()
-                print(f"FAILED ON ROW {i} with {e}")
-            ind += 1
+            p = FeynmanProblem(row, gen=gen, dp=dp)
+            ret.append(p)
     return ret
 
 

pysr/sr.py

@@ -1,12 +1,9 @@
 import os
 import sys
-from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
-from collections import namedtuple
-import pathlib
 import numpy as np
 import pandas as pd
 import sympy
-from sympy import sympify, Symbol, lambdify
+from sympy import sympify, lambdify
 import subprocess
 import tempfile
 import shutil
@@ -15,6 +12,26 @@ from datetime import datetime
 import warnings
 from multiprocessing import cpu_count
 
+is_julia_warning_silenced = False
+
+
+def install(julia_project=None):
+    import julia
+
+    julia.install()
+
+    julia_project = _get_julia_project(julia_project)
+
+    init_julia()
+    from julia import Pkg
+
+    Pkg.activate(f"{_escape_filename(julia_project)}")
+    Pkg.update()
+    Pkg.instantiate()
+    Pkg.precompile()
+
+
+Main = None
 global_state = dict(
     equation_file="hall_of_fame.csv",
     n_features=None,
@@ -27,8 +44,11 @@ global_state = dict(
     multioutput=False,
     nout=1,
     selection=None,
+    raw_julia_output=None,
 )
 
+already_ran = False
+
 sympy_mappings = {
     "div": lambda x, y: x / y,
     "mult": lambda x, y: x * y,
@@ -99,7 +119,6 @@ def pysr(
     weightRandomize=1,
     weightSimplify=0.01,
     perturbationFactor=1.0,
-    timeout=None,
     extra_sympy_mappings=None,
     extra_torch_mappings=None,
     extra_jax_mappings=None,
@@ -118,9 +137,7 @@ def pysr(
     useFrequency=True,
     tempdir=None,
     delete_tempfiles=True,
-    julia_optimization=3,
     julia_project=None,
-    user_input=True,
     update=True,
     temp_equation_file=False,
     output_jax_format=False,
@@ -135,6 +152,7 @@ def pysr(
     Xresampled=None,
     precision=32,
     multithreading=None,
+    **kwargs,
 ):
     """Run symbolic regression to fit f(X[i, :]) ~ y[i] for all i.
     Note: most default parameters have been tuned over several example
@@ -201,8 +219,6 @@ def pysr(
     :type weightRandomize: float
     :param weightSimplify: Relative likelihood for mutation to simplify constant parts by evaluation
     :type weightSimplify: float
-    :param timeout: Time in seconds to timeout search
-    :type timeout: float
     :param equation_file: Where to save the files (.csv separated by |)
     :type equation_file: str
     :param verbosity: What verbosity level to use. 0 means minimal print statements.
@@ -229,16 +245,12 @@ def pysr(
     :type constraints: dict
     :param useFrequency: whether to measure the frequency of complexities, and use that instead of parsimony to explore equation space. Will naturally find equations of all complexities.
     :type useFrequency: bool
-    :param julia_optimization: Optimization level (0, 1, 2, 3)
-    :type julia_optimization: int
     :param tempdir: directory for the temporary files
     :type tempdir: str/None
     :param delete_tempfiles: whether to delete the temporary files after finishing
     :type delete_tempfiles: bool
     :param julia_project: a Julia environment location containing a Project.toml (and potentially the source code for SymbolicRegression.jl).  Default gives the Python package directory, where a Project.toml file should be present from the install.
     :type julia_project: str/None
-    :param user_input: Whether to ask for user input or not for installing (to be used for automated scripts). Will choose to install when asked.
-    :type user_input: bool
     :param update: Whether to automatically update Julia packages.
     :type update: bool
     :param temp_equation_file: Whether to put the hall of fame file in the temp directory. Deletion is then controlled with the delete_tempfiles argument.
@@ -257,9 +269,13 @@ def pysr(
     :type precision: int
     :param multithreading: Use multithreading instead of distributed backend. Default is yes. Using procs=0 will turn off both.
     :type multithreading: bool
+    :param **kwargs: Other options passed to SymbolicRegression.Options, for example, if you modify SymbolicRegression.jl to include additional arguments.
+    :type **kwargs: dict
     :returns: Results dataframe, giving complexity, MSE, and equations (as strings), as well as functional forms. If list, each element corresponds to a dataframe of equations for each output.
     :type: pd.DataFrame/list
     """
+    global already_ran
+
     if binary_operators is None:
         binary_operators = "+ * - /".split(" ")
     if unary_operators is None:
@@ -275,6 +291,13 @@ def pysr(
         # or procs is set to 0 (serial mode).
         multithreading = procs != 0
 
+    global Main
+    if Main is None:
+        if multithreading:
+            os.environ["JULIA_NUM_THREADS"] = str(procs)
+
+        Main = init_julia()
+
     buffer_available = "buffer" in sys.stdout.__dir__()
 
     if progress is not None:
@@ -324,7 +347,6 @@ def pysr(
         weights,
         y,
     )
-    _check_for_julia_installation()
 
     if len(X) > 10000 and not batching:
         warnings.warn(
@@ -377,436 +399,206 @@ def pysr(
         else:
             X, y = _denoise(X, y, Xresampled=Xresampled)
 
-    kwargs = dict(
-        X=X,
-        y=y,
-        weights=weights,
-        alpha=alpha,
-        annealing=annealing,
-        batchSize=batchSize,
-        batching=batching,
-        binary_operators=binary_operators,
-        fast_cycle=fast_cycle,
-        fractionReplaced=fractionReplaced,
-        ncyclesperiteration=ncyclesperiteration,
-        niterations=niterations,
-        npop=npop,
-        topn=topn,
-        verbosity=verbosity,
-        progress=progress,
-        update=update,
-        julia_optimization=julia_optimization,
-        timeout=timeout,
-        fractionReplacedHof=fractionReplacedHof,
-        hofMigration=hofMigration,
-        maxdepth=maxdepth,
-        maxsize=maxsize,
-        migration=migration,
-        optimizer_algorithm=optimizer_algorithm,
-        optimizer_nrestarts=optimizer_nrestarts,
-        optimize_probability=optimize_probability,
-        optimizer_iterations=optimizer_iterations,
-        parsimony=parsimony,
-        perturbationFactor=perturbationFactor,
-        populations=populations,
-        procs=procs,
-        shouldOptimizeConstants=shouldOptimizeConstants,
-        unary_operators=unary_operators,
-        useFrequency=useFrequency,
-        use_custom_variable_names=use_custom_variable_names,
-        variable_names=variable_names,
-        warmupMaxsizeBy=warmupMaxsizeBy,
-        weightAddNode=weightAddNode,
-        weightDeleteNode=weightDeleteNode,
-        weightDoNothing=weightDoNothing,
-        weightInsertNode=weightInsertNode,
-        weightMutateConstant=weightMutateConstant,
-        weightMutateOperator=weightMutateOperator,
-        weightRandomize=weightRandomize,
-        weightSimplify=weightSimplify,
-        constraints=constraints,
-        extra_sympy_mappings=extra_sympy_mappings,
-        extra_jax_mappings=extra_jax_mappings,
-        extra_torch_mappings=extra_torch_mappings,
-        julia_project=julia_project,
-        loss=loss,
-        output_jax_format=output_jax_format,
-        output_torch_format=output_torch_format,
-        selection=selection,
-        multioutput=multioutput,
-        nout=nout,
-        tournament_selection_n=tournament_selection_n,
-        tournament_selection_p=tournament_selection_p,
-        denoise=denoise,
-        precision=precision,
-        multithreading=multithreading,
-    )
+    julia_project = _get_julia_project(julia_project)
 
-    kwargs = {**_set_paths(tempdir), **kwargs}
+    tmpdir = Path(tempfile.mkdtemp(dir=tempdir))
 
     if temp_equation_file:
-        equation_file = kwargs["tmpdir"] / "hall_of_fame.csv"
+        equation_file = tmpdir / "hall_of_fame.csv"
     elif equation_file is None:
         date_time = datetime.now().strftime("%Y-%m-%d_%H%M%S.%f")[:-3]
         equation_file = "hall_of_fame_" + date_time + ".csv"
 
-    kwargs = {**dict(equation_file=equation_file), **kwargs}
-
-    pkg_directory = kwargs["pkg_directory"]
-    if kwargs["julia_project"] is not None:
-        manifest_filepath = Path(kwargs["julia_project"]) / "Manifest.toml"
-    else:
-        manifest_filepath = pkg_directory / "Manifest.toml"
-
-    kwargs["need_install"] = False
-
-    if not (manifest_filepath).is_file():
-        kwargs["need_install"] = (not user_input) or _yesno(
-            "I will install Julia packages using PySR's Project.toml file. OK?"
-        )
-        if kwargs["need_install"]:
-            print("OK. I will install at launch.")
-            assert update
-
-    kwargs["def_hyperparams"] = _create_inline_operators(**kwargs)
-
-    _handle_constraints(**kwargs)
-
-    kwargs["constraints_str"] = _make_constraints_str(**kwargs)
-    kwargs["def_hyperparams"] = _make_hyperparams_julia_str(**kwargs)
-    kwargs["def_datasets"] = _make_datasets_julia_str(**kwargs)
-
-    _create_julia_files(**kwargs)
-    _final_pysr_process(**kwargs)
-    _set_globals(**kwargs)
-
-    equations = get_hof(**kwargs)
-
-    if delete_tempfiles:
-        shutil.rmtree(kwargs["tmpdir"])
-
-    return equations
-
-
-def _set_globals(X, **kwargs):
-    global global_state
-
-    global_state["n_features"] = X.shape[1]
-    for key, value in kwargs.items():
-        if key in global_state:
-            global_state[key] = value
-
-
-def _final_pysr_process(
-    julia_optimization, runfile_filename, timeout, multithreading, procs, **kwargs
-):
-    command = [
-        "julia",
-        f"-O{julia_optimization:d}",
-    ]
-
-    if multithreading:
-        command.append("--threads")
-        command.append(f"{procs}")
-
-    command.append(str(runfile_filename))
-    if timeout is not None:
-        command = ["timeout", f"{timeout}"] + command
-    _cmd_runner(command, **kwargs)
+    _create_inline_operators(
+        binary_operators=binary_operators, unary_operators=unary_operators
+    )
+    _handle_constraints(
+        binary_operators=binary_operators,
+        unary_operators=unary_operators,
+        constraints=constraints,
+    )
 
+    una_constraints = [constraints[op] for op in unary_operators]
+    bin_constraints = [constraints[op] for op in binary_operators]
 
-def _cmd_runner(command, progress, **kwargs):
-    if kwargs["verbosity"] > 0:
-        print("Running on", " ".join(command))
-    process = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=-1)
     try:
-        while True:
-            line = process.stdout.readline()
-            if not line:
-                break
-            decoded_line = line.decode("utf-8")
-            if progress:
-                decoded_line = (
-                    decoded_line.replace("\\033[K", "\033[K")
-                    .replace("\\033[1A", "\033[1A")
-                    .replace("\\033[1B", "\033[1B")
-                    .replace("\\r", "\r")
-                    .encode(sys.stdout.encoding, errors="replace")
-                )
-                sys.stdout.buffer.write(decoded_line)
-                sys.stdout.flush()
-            else:
-                print(decoded_line, end="")
-
-        process.stdout.close()
-        process.wait()
-    except KeyboardInterrupt:
-        print("Killing process... will return when done.")
-        process.kill()
-
-
-def _create_julia_files(
-    dataset_filename,
-    def_datasets,
-    hyperparam_filename,
-    def_hyperparams,
-    niterations,
-    runfile_filename,
-    julia_project,
-    procs,
-    weights,
-    X,
-    variable_names,
-    pkg_directory,
-    need_install,
-    update,
-    multithreading,
-    **kwargs,
-):
-    with open(hyperparam_filename, "w") as f:
-        print(def_hyperparams, file=f)
-    with open(dataset_filename, "w") as f:
-        print(def_datasets, file=f)
-    with open(runfile_filename, "w") as f:
-        if julia_project is None:
-            julia_project = pkg_directory
-        else:
-            julia_project = Path(julia_project)
-        print(f"import Pkg", file=f)
-        print(f'Pkg.activate("{_escape_filename(julia_project)}")', file=f)
-        if need_install:
-            print(f"Pkg.instantiate()", file=f)
-            print("Pkg.update()", file=f)
-            print("Pkg.precompile()", file=f)
-        elif update:
-            print(f"Pkg.update()", file=f)
-        print(f"using SymbolicRegression", file=f)
-        print(f'include("{_escape_filename(hyperparam_filename)}")', file=f)
-        print(f'include("{_escape_filename(dataset_filename)}")', file=f)
-        if len(variable_names) == 0:
-            varMap = "[" + ",".join([f'"x{i}"' for i in range(X.shape[1])]) + "]"
-        else:
-            varMap = (
-                "[" + ",".join(['"' + vname + '"' for vname in variable_names]) + "]"
-            )
+        term_width = shutil.get_terminal_size().columns
+    except:
+        _, term_width = subprocess.check_output(["stty", "size"]).split()
 
-        cprocs = 0 if multithreading else procs
-        if weights is not None:
-            print(
-                f"EquationSearch(X, y, weights=weights, niterations={niterations:d}, varMap={varMap}, options=options, numprocs={cprocs}, multithreading={'true' if multithreading else 'false'})",
-                file=f,
-            )
-        else:
-            print(
-                f"EquationSearch(X, y, niterations={niterations:d}, varMap={varMap}, options=options, numprocs={cprocs}, multithreading={'true' if multithreading else 'false'})",
-                file=f,
-            )
+    if not already_ran:
+        from julia import Pkg
+
+        Pkg.activate(f"{_escape_filename(julia_project)}")
+        if update:
+            try:
+                Pkg.resolve()
+            except RuntimeError as e:
+                raise ImportError(
+                    f"""
+Required dependencies are not installed or built.  Run the following code in the Python REPL:
+
+    >>> import pysr
+    >>> pysr.install()
+        
+Tried to activate project {julia_project} but failed."""
+                ) from e
+        Main.eval("using SymbolicRegression")
+
+        Main.plus = Main.eval("(+)")
+        Main.sub = Main.eval("(-)")
+        Main.mult = Main.eval("(*)")
+        Main.pow = Main.eval("(^)")
+        Main.div = Main.eval("(/)")
+
+    Main.custom_loss = Main.eval(loss)
+
+    mutationWeights = [
+        float(weightMutateConstant),
+        float(weightMutateOperator),
+        float(weightAddNode),
+        float(weightInsertNode),
+        float(weightDeleteNode),
+        float(weightSimplify),
+        float(weightRandomize),
+        float(weightDoNothing),
+    ]
 
+    options = Main.Options(
+        binary_operators=Main.eval(str(tuple(binary_operators)).replace("'", "")),
+        unary_operators=Main.eval(str(tuple(unary_operators)).replace("'", "")),
+        bin_constraints=bin_constraints,
+        una_constraints=una_constraints,
+        parsimony=float(parsimony),
+        loss=Main.custom_loss,
+        alpha=float(alpha),
+        maxsize=int(maxsize),
+        maxdepth=int(maxdepth),
+        fast_cycle=fast_cycle,
+        migration=migration,
+        hofMigration=hofMigration,
+        fractionReplacedHof=float(fractionReplacedHof),
+        shouldOptimizeConstants=shouldOptimizeConstants,
+        hofFile=_escape_filename(equation_file),
+        npopulations=int(populations),
+        optimizer_algorithm=optimizer_algorithm,
+        optimizer_nrestarts=int(optimizer_nrestarts),
+        optimize_probability=float(optimize_probability),
+        optimizer_iterations=int(optimizer_iterations),
+        perturbationFactor=float(perturbationFactor),
+        annealing=annealing,
+        batching=batching,
+        batchSize=int(min([batchSize, len(X)]) if batching else len(X)),
+        mutationWeights=mutationWeights,
+        warmupMaxsizeBy=float(warmupMaxsizeBy),
+        useFrequency=useFrequency,
+        npop=int(npop),
+        ns=int(tournament_selection_n),
+        probPickFirst=float(tournament_selection_p),
+        ncyclesperiteration=int(ncyclesperiteration),
+        fractionReplaced=float(fractionReplaced),
+        topn=int(topn),
+        verbosity=int(verbosity),
+        progress=progress,
+        terminal_width=int(term_width),
+        **kwargs,
+    )
 
-def _make_datasets_julia_str(
-    X,
-    X_filename,
-    weights,
-    weights_filename,
-    y,
-    y_filename,
-    multioutput,
-    precision,
-    **kwargs,
-):
-    def_datasets = """using DelimitedFiles"""
-    julia_dtype = {16: "Float16", 32: "Float32", 64: "Float64"}[precision]
     np_dtype = {16: np.float16, 32: np.float32, 64: np.float64}[precision]
 
-    np.savetxt(X_filename, X.astype(np_dtype), delimiter=",")
-    if multioutput:
-        np.savetxt(y_filename, y.astype(np_dtype), delimiter=",")
+    Main.X = np.array(X, dtype=np_dtype).T
+    if len(y.shape) == 1:
+        Main.y = np.array(y, dtype=np_dtype)
     else:
-        np.savetxt(y_filename, y.reshape(-1, 1).astype(np_dtype), delimiter=",")
-
+        Main.y = np.array(y, dtype=np_dtype).T
     if weights is not None:
-        if multioutput:
-            np.savetxt(weights_filename, weights.astype(np_dtype), delimiter=",")
+        if len(weights.shape) == 1:
+            Main.weights = np.array(weights, dtype=np_dtype)
         else:
-            np.savetxt(
-                weights_filename,
-                weights.reshape(-1, 1).astype(np_dtype),
-                delimiter=",",
-            )
+            Main.weights = np.array(weights, dtype=np_dtype).T
+    else:
+        Main.weights = None
+
+    cprocs = 0 if multithreading else procs
+
+    raw_julia_output = Main.EquationSearch(
+        Main.X,
+        Main.y,
+        weights=Main.weights,
+        niterations=int(niterations),
+        varMap=variable_names,
+        options=options,
+        numprocs=int(cprocs),
+        multithreading=bool(multithreading),
+    )
 
-    def_datasets += f"""
-X = copy(transpose(readdlm("{_escape_filename(X_filename)}", ',', {julia_dtype}, '\\n')))"""
+    _set_globals(
+        X=X,
+        equation_file=equation_file,
+        variable_names=variable_names,
+        extra_sympy_mappings=extra_sympy_mappings,
+        extra_torch_mappings=extra_torch_mappings,
+        extra_jax_mappings=extra_jax_mappings,
+        output_jax_format=output_jax_format,
+        output_torch_format=output_torch_format,
+        multioutput=multioutput,
+        nout=nout,
+        selection=selection,
+        raw_julia_output=raw_julia_output,
+    )
 
-    if multioutput:
-        def_datasets += f"""
-y = copy(transpose(readdlm("{_escape_filename(y_filename)}", ',', {julia_dtype}, '\\n')))"""
-    else:
-        def_datasets += f"""
-y = readdlm("{_escape_filename(y_filename)}", ',', {julia_dtype}, '\\n')[:, 1]"""
+    equations = get_hof(
+        equation_file=equation_file,
+        n_features=X.shape[1],
+        variable_names=variable_names,
+        output_jax_format=output_jax_format,
+        output_torch_format=output_torch_format,
+        selection=selection,
+        extra_sympy_mappings=extra_sympy_mappings,
+        extra_jax_mappings=extra_jax_mappings,
+        extra_torch_mappings=extra_torch_mappings,
+        multioutput=multioutput,
+        nout=nout,
+    )
 
-    if weights is not None:
-        if multioutput:
-            def_datasets += f"""
-weights = copy(transpose(readdlm("{_escape_filename(weights_filename)}", ',', {julia_dtype}, '\\n')))"""
-        else:
-            def_datasets += f"""
-weights = readdlm("{_escape_filename(weights_filename)}", ',', {julia_dtype}, '\\n')[:, 1]"""
-    return def_datasets
+    if delete_tempfiles:
+        shutil.rmtree(tmpdir)
+
+    return equations
 
 
-def _make_hyperparams_julia_str(
+def _set_globals(
+    *,
     X,
-    alpha,
-    annealing,
-    batchSize,
-    batching,
-    binary_operators,
-    constraints_str,
-    def_hyperparams,
     equation_file,
-    fast_cycle,
-    fractionReplacedHof,
-    hofMigration,
-    maxdepth,
-    maxsize,
-    migration,
-    optimizer_algorithm,
-    optimizer_nrestarts,
-    optimize_probability,
-    optimizer_iterations,
-    npop,
-    parsimony,
-    perturbationFactor,
-    populations,
-    shouldOptimizeConstants,
-    unary_operators,
-    useFrequency,
-    warmupMaxsizeBy,
-    weightAddNode,
-    ncyclesperiteration,
-    fractionReplaced,
-    topn,
-    verbosity,
-    progress,
-    loss,
-    weightDeleteNode,
-    weightDoNothing,
-    weightInsertNode,
-    weightMutateConstant,
-    weightMutateOperator,
-    weightRandomize,
-    weightSimplify,
-    tournament_selection_n,
-    tournament_selection_p,
-    **kwargs,
+    variable_names,
+    extra_sympy_mappings,
+    extra_torch_mappings,
+    extra_jax_mappings,
+    output_jax_format,
+    output_torch_format,
+    multioutput,
+    nout,
+    selection,
+    raw_julia_output,
 ):
-    try:
-        term_width = shutil.get_terminal_size().columns
-    except:
-        _, term_width = subprocess.check_output(["stty", "size"]).split()
+    global global_state
 
-    def tuple_fix(ops):
-        if len(ops) > 1:
-            return ", ".join(ops)
-        if len(ops) == 0:
-            return ""
-        return ops[0] + ","
-
-    def_hyperparams += f"""\n
-plus=(+)
-sub=(-)
-mult=(*)
-square=SymbolicRegression.square
-cube=SymbolicRegression.cube
-pow=(^)
-div=(/)
-log_abs=SymbolicRegression.log_abs
-log2_abs=SymbolicRegression.log2_abs
-log10_abs=SymbolicRegression.log10_abs
-log1p_abs=SymbolicRegression.log1p_abs
-acosh_abs=SymbolicRegression.acosh_abs
-atanh_clip=SymbolicRegression.atanh_clip
-sqrt_abs=SymbolicRegression.sqrt_abs
-neg=SymbolicRegression.neg
-greater=SymbolicRegression.greater
-relu=SymbolicRegression.relu
-logical_or=SymbolicRegression.logical_or
-logical_and=SymbolicRegression.logical_and
-_custom_loss = {loss}
-
-options = SymbolicRegression.Options(binary_operators={'(' + tuple_fix(binary_operators) + ')'},
-unary_operators={'(' + tuple_fix(unary_operators) + ')'},
-{constraints_str}
-parsimony={parsimony:f}f0,
-loss=_custom_loss,
-alpha={alpha:f}f0,
-maxsize={maxsize:d},
-maxdepth={maxdepth:d},
-fast_cycle={'true' if fast_cycle else 'false'},
-migration={'true' if migration else 'false'},
-hofMigration={'true' if hofMigration else 'false'},
-fractionReplacedHof={fractionReplacedHof}f0,
-shouldOptimizeConstants={'true' if shouldOptimizeConstants else 'false'},
-hofFile="{_escape_filename(equation_file)}",
-npopulations={populations:d},
-optimizer_algorithm="{optimizer_algorithm}",
-optimizer_nrestarts={optimizer_nrestarts:d},
-optimize_probability={optimize_probability:f}f0,
-optimizer_iterations={optimizer_iterations:d},
-perturbationFactor={perturbationFactor:f}f0,
-annealing={"true" if annealing else "false"},
-batching={"true" if batching else "false"},
-batchSize={min([batchSize, len(X)]) if batching else len(X):d},
-mutationWeights=[
-    {weightMutateConstant:f},
-    {weightMutateOperator:f},
-    {weightAddNode:f},
-    {weightInsertNode:f},
-    {weightDeleteNode:f},
-    {weightSimplify:f},
-    {weightRandomize:f},
-    {weightDoNothing:f}
-],
-warmupMaxsizeBy={warmupMaxsizeBy:f}f0,
-useFrequency={"true" if useFrequency else "false"},
-npop={npop:d},
-ns={tournament_selection_n:d},
-probPickFirst={tournament_selection_p:f}f0,
-ncyclesperiteration={ncyclesperiteration:d},
-fractionReplaced={fractionReplaced:f}f0,
-topn={topn:d},
-verbosity=round(Int32, {verbosity:f}),
-progress={'true' if progress else 'false'},
-terminal_width={term_width:d}
-"""
-
-    def_hyperparams += "\n)"
-    return def_hyperparams
-
-
-def _make_constraints_str(binary_operators, constraints, unary_operators, **kwargs):
-    constraints_str = "una_constraints = ["
-    first = True
-    for op in unary_operators:
-        val = constraints[op]
-        if not first:
-            constraints_str += ", "
-        constraints_str += f"{val:d}"
-        first = False
-    constraints_str += """],
-bin_constraints = ["""
-    first = True
-    for op in binary_operators:
-        tup = constraints[op]
-        if not first:
-            constraints_str += ", "
-        constraints_str += f"({tup[0]:d}, {tup[1]:d})"
-        first = False
-    constraints_str += "],"
-    return constraints_str
+    global_state["n_features"] = X.shape[1]
+    global_state["equation_file"] = equation_file
+    global_state["variable_names"] = variable_names
+    global_state["extra_sympy_mappings"] = extra_sympy_mappings
+    global_state["extra_torch_mappings"] = extra_torch_mappings
+    global_state["extra_jax_mappings"] = extra_jax_mappings
+    global_state["output_jax_format"] = output_jax_format
+    global_state["output_torch_format"] = output_torch_format
+    global_state["multioutput"] = multioutput
+    global_state["nout"] = nout
+    global_state["selection"] = selection
+    global_state["raw_julia_output"] = raw_julia_output
 
 
-def _handle_constraints(binary_operators, constraints, unary_operators, **kwargs):
+def _handle_constraints(binary_operators, unary_operators, constraints):
     for op in unary_operators:
         if op not in constraints:
             constraints[op] = -1
@@ -829,14 +621,13 @@ def _handle_constraints(binary_operators, constraints, unary_operators, **kwargs
                 )
 
 
-def _create_inline_operators(binary_operators, unary_operators, **kwargs):
-    def_hyperparams = ""
+def _create_inline_operators(binary_operators, unary_operators):
     for op_list in [binary_operators, unary_operators]:
         for i, op in enumerate(op_list):
             is_user_defined_operator = "(" in op
 
             if is_user_defined_operator:
-                def_hyperparams += op + "\n"
+                Main.eval(op)
                 # Cut off from the first non-alphanumeric char:
                 first_non_char = [
                     j
@@ -845,7 +636,6 @@ def _create_inline_operators(binary_operators, unary_operators, **kwargs):
                 ][0]
                 function_name = op[:first_non_char]
                 op_list[i] = function_name
-    return def_hyperparams
 
 
 def _handle_feature_selection(
@@ -863,30 +653,6 @@ def _handle_feature_selection(
     return X, variable_names, selection
 
 
-def _set_paths(tempdir):
-    # System-independent paths
-    pkg_directory = Path(__file__).parents[1]
-    default_project_file = pkg_directory / "Project.toml"
-    tmpdir = Path(tempfile.mkdtemp(dir=tempdir))
-    hyperparam_filename = tmpdir / f"hyperparams.jl"
-    dataset_filename = tmpdir / f"dataset.jl"
-    runfile_filename = tmpdir / "runfile.jl"
-    X_filename = tmpdir / "X.csv"
-    y_filename = tmpdir / "y.csv"
-    weights_filename = tmpdir / "weights.csv"
-    return dict(
-        pkg_directory=pkg_directory,
-        default_project_file=default_project_file,
-        X_filename=X_filename,
-        dataset_filename=dataset_filename,
-        hyperparam_filename=hyperparam_filename,
-        runfile_filename=runfile_filename,
-        tmpdir=tmpdir,
-        weights_filename=weights_filename,
-        y_filename=y_filename,
-    )
-
-
 def _check_assertions(
     X,
     binary_operators,
@@ -908,30 +674,13 @@ def _check_assertions(
         assert len(variable_names) == X.shape[1]
 
 
-def _check_for_julia_installation():
-    try:
-        process = subprocess.Popen(["julia", "-v"], stdout=subprocess.PIPE, bufsize=-1)
-        while True:
-            line = process.stdout.readline()
-            if not line:
-                break
-        process.stdout.close()
-        process.wait()
-    except FileNotFoundError:
-
-        raise RuntimeError(
-            f"Your current $PATH is: {os.environ['PATH']}\nPySR could not start julia. Make sure julia is installed and on your $PATH."
-        )
-    process.kill()
-
-
 def run_feature_selection(X, y, select_k_features):
     """Use a gradient boosting tree regressor as a proxy for finding
     the k most important features in X, returning indices for those
     features as output."""
 
     from sklearn.ensemble import RandomForestRegressor
-    from sklearn.feature_selection import SelectFromModel, SelectKBest
+    from sklearn.feature_selection import SelectFromModel
 
     clf = RandomForestRegressor(n_estimators=100, max_depth=3, random_state=0)
     clf.fit(X, y)
@@ -1068,7 +817,9 @@ def get_hof(
                 cur_score = 0.0
             else:
                 if curMSE > 0.0:
-                    cur_score = -np.log(curMSE / lastMSE) / (curComplexity - lastComplexity)
+                    cur_score = -np.log(curMSE / lastMSE) / (
+                        curComplexity - lastComplexity
+                    )
                 else:
                     cur_score = np.inf
 
@@ -1197,3 +948,56 @@ class CallableEquation:
         if self._selection is not None:
             return self._lambda(*X[:, self._selection].T)
         return self._lambda(*X.T)
+
+
+def _get_julia_project(julia_project):
+    pkg_directory = Path(__file__).parents[1]
+    if julia_project is None:
+        return pkg_directory
+    return Path(julia_project)
+
+
+def silence_julia_warning():
+    global is_julia_warning_silenced
+    is_julia_warning_silenced = True
+
+
+def init_julia():
+    """Initialize julia binary, turning off compiled modules if needed."""
+    global is_julia_warning_silenced
+    from julia.core import JuliaInfo, UnsupportedPythonError
+
+    info = JuliaInfo.load(julia="julia")
+    if not info.is_pycall_built():
+        raise ImportError(
+            """
+    Required dependencies are not installed or built.  Run the following code in the Python REPL:
+
+    >>> import pysr
+    >>> pysr.install()"""
+        )
+
+    Main = None
+    try:
+        from julia import Main as _Main
+
+        Main = _Main
+    except UnsupportedPythonError:
+        if not is_julia_warning_silenced:
+            warnings.warn(
+                """
+Your Python version is statically linked to libpython. For example, this could be the python included with conda, or maybe your system's built-in python.
+This will still work, but the precompilation cache for Julia will be turned off, which may result in slower startup times on the initial pysr() call.
+
+To install a Python version that is dynamically linked to libpython, pyenv is recommended (https://github.com/pyenv/pyenv).
+
+To silence this warning, you can run pysr.silence_julia_warning() after importing pysr."""
+            )
+        from julia.core import Julia
+
+        jl = Julia(compiled_modules=False)
+        from julia import Main as _Main
+
+        Main = _Main
+
+    return Main

requirements.txt

@@ -2,3 +2,4 @@ sympy
 pandas
 numpy
 scikit_learn
+julia

setup.py

@@ -5,14 +5,14 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="pysr",
-    version="0.6.14",
+    version="0.7.0a1",
     author="Miles Cranmer",
     author_email="miles.cranmer@gmail.com",
     description="Simple and efficient symbolic regression",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/MilesCranmer/pysr",
-    install_requires=["numpy", "pandas", "sympy"],
+    install_requires=["julia", "numpy", "pandas", "sympy"],
     packages=setuptools.find_packages(),
     package_data={"pysr": ["../Project.toml", "../datasets/*"]},
     include_package_data=False,

test/test.py

@@ -13,7 +13,6 @@ class TestPipeline(unittest.TestCase):
         self.default_test_kwargs = dict(
             niterations=10,
             populations=4,
-            user_input=False,
             annealing=True,
             useFrequency=False,
         )

test/test_static_libpython_warning.py

@@ -0,0 +1,13 @@
+"""Test that running PySR with static libpython raises a warning."""
+
+import warnings
+import pysr
+
+# Taken from https://stackoverflow.com/a/14463362/2689923
+with warnings.catch_warnings(record=True) as warning_catcher:
+    warnings.simplefilter("always")
+    pysr.sr.init_julia()
+
+    assert len(warning_catcher) == 1
+    assert issubclass(warning_catcher[-1].category, UserWarning)
+    assert "static" in str(warning_catcher[-1].message)