PK!Fcreg_bench/__init__.pyfrom .__version__ import __version__ from .maps import all_maps from .ode import all_ode all_problems = {} for typ, dct in zip(["map", "ode"], [all_maps, all_ode]): for k, v in dct.items(): all_problems[k] = v all_problems[k]["type"] = typ del all_maps del all_ode PK!Jgreg_bench/__version__.py__version__ = "0.0.3" PK!%%reg_bench/maps/__init__.pyimport numpy as np from toolz.itertoolz import iterate from toolz.itertoolz import take from .maps import all_maps def generate_map_data(problem, x0, t, params): f = problem(params) x = take(iterate(f, x0), t + 1) x = np.array(x) return x[:-1], x[1:] PK!74reg_bench/maps/maps.pyimport functools import numpy as np from ..utils import make_register all_maps = {} register_map = make_register(all_maps) @register_map(2, "polynomial") def henon(a=1.4, b=0.3): @functools.wraps(henon) def f(state): x, y = state return y + 1 - a * x ** 2, b * x return f @register_map(2) def chirikov(K=1): @functools.wraps(chirikov) def f(state): p, theta = state p_1 = p + K * np.sin(theta) theta_1 = theta + p_1 return p_1, theta_1 return f @register_map(1, "polynomial") def logistic(r=3.18): @functools.wraps(logistic) def f(x): return r * x * (1 - x) return f @register_map(2, "polynomial") def bogdanov(eps, k, mu): @functools.wraps(bogdanov) def f(state): x, y = state return x + y, (1 + eps) * y + k * x * (x - 1) + mu * x * y @register_map(2, "polynomial") def duffing(a=2.75, b=0.15): @functools.wraps(duffing) def f(state): x, y = state return y, -b * x + a * y - y ** 3 return f @register_map(2, "polynomial") def tinkerbell(a=0.9, b=-0.6013, c=2.0, d=0.5): @functools.wraps(tinkerbell) def f(state): x, y = state return x ** 2 - y ** 2 + a * x + b * y, 2 * x * y + c * x + d * y return f PK!Freg_bench/ode/__init__.pyfrom .integrate import generate_ode_data from .not_so_simple_ode import * from .simple_ode import * from .simple_ode import all_loaders as simple_ode_loaders all_loaders = {**simple_ode_loaders} PK!~1ܻreg_bench/ode/integrate.pyfrom functools import wraps import numpy as np import scipy.integrate from derivative import derivative def generate_ode_data( problem, x0, t, ode_params=None, noise_amplitude=0, noise_pdf=None, noise_params=None, noise_kind="additive", diff_params=None, ): """Generate a trajectory and estimate its derivate. Noise will be added as measurement noise before estimating the derivatives. Args: problem: ode generator x0: initial conditions t: timestamps of the output ode_params: kwargs for problem noise_kind: proportional or additive noise_amplitude: noise amplitude noise_pdf: function which generates noise noise_params: kwargs passed to noise_pdf derive_max_order: maximum order derivative Returns: x, dx: trajectory and derivative """ dy = problem(**(ode_params or {})) x = scipy.integrate.odeint(dy, x0, t) x = add_measurement_noise( x, noise_amplitude=noise_amplitude, noise_pdf=noise_pdf, noise_params=noise_params, noise_kind=noise_kind, ) dx = derivative(t, x, **(diff_params or {})) return x, dx def add_measurement_noise(x, noise_amplitude=0, noise_pdf=None, noise_params=None, noise_kind="additive"): """Add measurement noise to a trajectory.""" noise_pdf = noise_pdf or np.random.normal noise_params = noise_params or {} if noise_amplitude > 0: if noise_kind == "proportional": return x * (1 + noise_amplitude * noise_pdf(size=x.shape, **noise_params)) return x + noise_amplitude * noise_pdf(size=x.shape, **noise_params) return x PK!_700"reg_bench/ode/not_so_simple_ode.pyimport functools import random import numpy as np class ODE: def ode(self, **params): raise NotImplementedError @property def params(self): raise NotImplementedError def __call__(self): return self.ode(**self.params) class yeast_glycolysis(ODE): def __init__(self): """As of doi:10.1371/journal.pone.0119821.t002 Table 2 """ s1 = 0.15, 1.6 s2 = 0.19, 2.16 s3 = 0.04, 0.20 s4 = 0.1, 0.35 s5 = 0.08, 0.3 s6 = 0.14, 2.67 s7 = 0.05, 0.1 # sig1 = 1.8442 # sig2 = 3.0449 # sig3 = 0.1438 # sig4 = 0.2746 # sig5 = 0.1143 # sig6 = 3.4437 # sig7 = 0.0489 sig1 = 0.4862 # Table 2 MD Schmidt et al. # doi: 10.1088/1478-3975/8/5/055011 sig2 = 0.6263 sig3 = 0.0503 sig4 = 0.0814 sig5 = 0.0379 sig6 = 0.7478 sig7 = 0.0159 self.range = [s1, s2, s3, s4, s5, s6, s6] self.sigma = [sig1, sig2, sig3, sig4, sig5, sig6, sig7] def initial_conditions(self, noise=True, rng=random): noise = int(noise) return [ max(0, rng.uniform(up, low) + rng.gauss(0, sigma)) for (up, low), sigma in zip(self.range, self.sigma) ] @property def params(self): """As of doi:10.1371/journal.pone.0119821.t00 Table 1. """ p = dict( j0=2.5, # mM min^-1 k1=100.0, # mM^-1 min^-1 k2=6.0, # mM^-1 min^-1 k3=16.0, # mM^-1 min^-1 k4=100.0, # mM^-1 min^-1 k5=1.28, # min^-1 k6=12.0, # mM^-1 min^-1 k=1.8, # min^-1 kappa=13.0, # min^-1 q=4.0, # K1=0.52, # mM psi=0.1, # n=1.0, # mM a=4.0, # mM ) return p def ode(self, j0, k1, k2, k3, k4, k5, k6, k, kappa, q, K1, psi, n, a): """ Ruoff P, Christensen M, Wolf J, Heinrich R. Temperature dependency and temperature compensation in a model of yeast glycolytic oscillations. Biophys Chem 2003; 106: 179. doi: 10.1016/S0301-4622(03) 00191-1 PMID: 14556906 """ # @functools.wraps(self.ode) def dy(y, t): s1, s2, s3, s4, s5, s6, s7 = y h1 = 2.0 * k1 * s1 * s6 / (1.0 + (s6 / K1) ** q) h2 = k6 * s2 * s5 h3 = k2 * s2 * (n - s5) h4 = k3 * s3 * (a - s6) h5 = k4 * s4 * s5 ds1 = j0 - h1 / 2.0 ds2 = h1 - h3 - h2 ds3 = h3 - h4 ds4 = h4 - h5 - kappa * (s4 - s7) ds5 = h3 - h5 - h2 ds6 = -h1 + 2 * h4 - k5 * s6 ds7 = psi * kappa * (s4 - s7) - k * s7 return [ds1, ds2, ds3, ds4, ds5, ds6, ds7] return dy class double_pendulum(ODE): def initial_conditions(self): return [0, 0, 1, 0] @property def params(self): p = dict(m=1, l=1, g=9.81) return p def ode(self, m, l, g): def dy(y, t): phi1, phi2, p1, p2 = y Dphi = phi1 - phi2 temp = m * l ** 2 denom = 16.0 - 9 * np.cos(Dphi) ** 2 dphi1 = 6.0 / temp * (2.0 * p1 - 3.0 * np.cos(Dphi) * p2) / denom dphi2 = 6.0 / temp * (2.0 * p2 - 3.0 * np.cos(Dphi) * p1) / denom temp2 = dphi1 * dphi2 * np.sin(Dphi) dp1 = -0.5 * temp * (temp2 + 3 * g / l * np.sin(phi1)) dp2 = -0.5 * temp * (-temp2 + g / l * np.sin(phi2)) return [dphi1, dphi2, dp1, dp2] return dy @staticmethod def get_cartesian_coords(phi1, phi2, l): x1 = l / 2.0 * np.sin(phi1) y1 = -l / 2.0 * np.cos(phi1) x2 = x1 + l * np.sin(phi2) y2 = x2 + l * np.cos(phi2) return x1, y1, x2, y2 PK!fu"reg_bench/ode/simple_ode.pyimport functools import inspect import sys import numpy as np from sklearn.datasets.base import Bunch from ..utils import make_register from .integrate import generate_ode_data all_ode = {} register_ode = make_register(all_ode) @register_ode(2, "linear", "polynomial") def harmonic_oscillator(omega=1.0): @functools.wraps(harmonic_oscillator) def dy(y, t): dy0 = y[1] dy1 = -omega ** 2 * y[0] return [dy0, dy1] return dy @register_ode(2, "polynomial") def anharmonic_oscillator(omega=1.0, c=1.0, l=1.0): @functools.wraps(anharmonic_oscillator) def dy(y, t): dy0 = y[1] dy1 = -omega ** 2 * y[0] - l * y[0] ** 2 - c * y[1] return [dy0, dy1] return dy @register_ode(3, "polynomial") def lorenz(s=10.0, r=28.0, b=8.0 / 3.0): @functools.wraps(lorenz) def dy(y, t): dy0 = s * (y[1] - y[0]) dy1 = r * y[0] - y[1] - y[0] * y[2] dy2 = y[0] * y[1] - b * y[2] return [dy0, dy1, dy2] return dy @register_ode(2, "polynomial") def van_der_pol(omega=1.0, a=0.1, b=0.01): @functools.wraps(van_der_pol) def dy(y, t): y0, y1 = y dy0 = y1 dy1 = -omega ** 2 * y0 + a * y1 * (1 - b * y0 ** 2) return dy0, dy1 return dy @register_ode(2) def michaelis_menten(vmax=0.25, Km=0.1, rho=1.0): @functools.wraps(michaelis_menten) def dy(y, t): s, p = y dp = vmax * s ** rho / (Km + s ** rho) ds = -dp return [ds, dp] return dy @register_ode(3, "polynomial") def rössler(a=0.15, b=0.20, c=10.0): @functools.wraps(rössler) def dy_(state, t): x, y, z = state dx = -y - z dy = x + a * y dz = b + (x - c) * z return [dx, dy, dz] return dy_ @register_ode(2, "polynomial") def brusselator(a=1.0, b=3.0): @functools.wraps(brusselator) def dy_(state, t): x, y = state dx = a + x ** 2 * y - (b + 1) * x dy = b * x - x ** 2 * y return dx, dy return dy_ @register_ode(2) def magnets(K=0.25): @functools.wraps(magnets) def dy(state, t): theta1, theta2 = state dtheta1 = K * np.sin(theta1 - theta2) - np.sin(theta1) dtheta2 = K * np.sin(theta2 - theta1) - np.sin(theta2) return dtheta1, dtheta2 return dy @register_ode(2) def predator_prey(a=0.5, b=0.5): @functools.wraps(predator_prey) def dy_(state, t): x, y = state dx = x * (b - x - y / (1.0 + x)) dy = y * (x / (1 + x) - a * y) return dx, dy return dy_ @register_ode(2) def bacterial_respiration(a=0.1, b=0.2, q=1.0): @functools.wraps(bacterial_respiration) def dy_(state, t): x, y = state temp = x * y / (1 + q * x ** 2) dx = b - x - temp dy = a - temp return dx, dy return dy_ @register_ode(2) def glider(d=1.0): @functools.wraps(glider) def dy(state, t): v, theta = state dv = -np.sin(theta) - d * v ** 2 dtheta = -np.cos(theta) / v + v return dv, dtheta return dy @register_ode(2) def shear_flow(a=0.3): @functools.wraps(shear_flow) def dy(state, t): theta, phi = state dtheta = np.tan(phi) ** (-1) * np.cos(theta) dphi = (np.cos(phi) ** 2 + a * np.sin(phi) ** 2) * np.sin(theta) return dtheta, dphi return dy def make_bunch(data_config): default_params = lambda: { p.name: p.default for p in inspect.signature(data_config["problem"]).parameters.values() } data_config["ode_params"] = data_config.get("ode_params", default_params()) x, dx = generate_ode_data(**data_config) return Bunch(data=x, target=dx, x0=data_config["x0"], params=data_config["ode_params"], t=data_config["t"]) def make_load(ode, t=np.linspace(0, 100, 10001, endpoint=True), x0=1): arity = all_ode[ode]["arity"] data_config = dict(problem=ode, x0=np.ones(arity) * x0, t=t) def loader(): return make_bunch(data_config) loader.__name__ = "load_" + all_ode[ode]["name"] # register loader to the simple_ode module caller = inspect.getframeinfo(inspect.stack()[1][0]) # find current_module by looking up caller in stack name = inspect.getmodulename(caller.filename) current_module = [mod for mname, mod in sys.modules.items() if name == mname.split(".")[-1]][0] if loader.__name__ not in dir(current_module): setattr(current_module, loader.__name__, loader) return loader all_loaders = {all_ode[ode]["name"]: make_load(ode) for ode in all_ode} PK!MjCC)reg_bench/symbolic_regression/__init__.py""" This module implements all 53 benchmark problems of "GP Needs Better Benchmarks" by McDermott et. al. DOI: 10.1145/2330163.2330273 """ from .keijzer import all_problems as keijzer_all from .korns import all_problems as korns_all from .koza import all_problems as koza_all from .nguyen import all_problems as nguyen_all from .pagie import all_problems as pagie_all from .vladislavleva import all_problems as vladislavleva_all all_problems = { **koza_all, **nguyen_all, **nguyen_all, **pagie_all, **korns_all, **keijzer_all, **vladislavleva_all, } PK!)(reg_bench/symbolic_regression/keijzer.pyimport sys from functools import partial import numpy as np from .util import generate_evenly_spaced_data_set from .util import generate_uniform_data_set from .util import generator_from_helper """ Sets of "Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" by Maarten Keijzer DOI: 10.1007/3-540-36599-0_7 """ def keijzer_func4(x): return 0.3 * x * np.sin(2.0 * np.pi * x) def keijzer_func5(x): sx = np.sin(x) cx = np.cos(x) return x ** 3 * np.exp(-x) * cx * sx * (sx ** 2 * cx - 1.0) def keijzer_func6(x, y, z): return 30.0 * x * z / ((x - 10.0) * y ** 2) def keijzer_func7(x): f = lambda n: sum(1.0 / i for i in range(1, int(n))) if any(x < 0): raise ValueError if isinstance(x, np.ndarray): return np.array([f(n) for n in x]) else: return f(x) def keijzer_func8(x): return np.log(x) def keijzer_func9(x): return np.sqrt(x) def keijzer_func10(x): return np.arcsinh(x) def keijzer_func11(x, y): return x ** y def keijzer_func12(x, y): return x * y + np.sin((x - 1.0) * (y - 1.0)) def keijzer_func13(x, y): return x ** 4 - x ** 3 + 0.5 * y ** 2 - y def keijzer_func14(x, y): return 6.0 * np.sin(x) * np.cos(x) def keijzer_func15(x, y): return 8.0 / (2.0 + x ** 2 + y ** 2) def keijzer_func16(x, y): return x ** 3 / 3.0 + y ** 3 / 2.0 - y - x def _keijzer1_3_helper(step, ranges): return generate_evenly_spaced_data_set(keijzer_func4, step, ranges) def generate_keijzer1(): ranges = (-1, 1) train = _keijzer1_3_helper(0.1, ranges) test = _keijzer1_3_helper(0.001, ranges) return train, test def generate_keijzer2(): ranges = (-2, 2) train = _keijzer1_3_helper(0.1, ranges) test = _keijzer1_3_helper(0.001, ranges) return train, test def generate_keijzer3(): ranges = (-4, 4) train = _keijzer1_3_helper(0.1, ranges) test = _keijzer1_3_helper(0.001, ranges) return train, test def generate_keijzer4(): train = generate_evenly_spaced_data_set(keijzer_func5, 0.05, (0, 10)) test = generate_evenly_spaced_data_set(keijzer_func5, 0.05, (0.05, 10.05)) return train, test def generate_keijzer5(rng=np.random): ranges = [(-1, 1), (1, 2), (-1, 1)] train = generate_uniform_data_set(keijzer_func6, 1000, ranges, rng=rng) test = generate_uniform_data_set(keijzer_func6, 10000, ranges, rng=rng) return train, test def generate_keijzer6(): train = generate_evenly_spaced_data_set(keijzer_func7, 1.0, (1, 50)) test = generate_evenly_spaced_data_set(keijzer_func7, 1.0, (1, 120)) return train, test def generate_keijzer7(): train = generate_evenly_spaced_data_set(keijzer_func8, 1.0, (1, 100)) test = generate_evenly_spaced_data_set(keijzer_func8, 0.01, (1, 100)) return train, test def generate_keijzer8(): train = generate_evenly_spaced_data_set(keijzer_func9, 1.0, (0, 100)) test = generate_evenly_spaced_data_set(keijzer_func9, 0.01, (0, 100)) return train, test def generate_keijzer9(): train = generate_evenly_spaced_data_set(keijzer_func10, 1.0, (0, 100)) test = generate_evenly_spaced_data_set(keijzer_func10, 0.01, (0, 100)) return train, test def generate_keijzer10(rng=np.random): train = generate_uniform_data_set(keijzer_func11, 100, (0, 1), rng=rng) test = generate_evenly_spaced_data_set(keijzer_func11, 0.01, (0, 1)) return train, test def _keijzer11_15_helper(func, rng=np.random): train = generate_uniform_data_set(func, 20, (-3, 3), rng=rng) test = generate_evenly_spaced_data_set(func, 0.01, (-3, 3)) return train, test generator_from_helper(_keijzer11_15_helper, shift=-1, i=list(range(12, 16))) current_module = sys.modules[__name__] all_problems = {name: getattr(current_module, name) for name in locals() if "generate_keijzer" in name} PK!Wa&reg_bench/symbolic_regression/korns.pyimport sys from functools import partial import numpy as np from .util import generate_uniform_data_set from .util import generator_from_helper """ Sets of "Accuracy in Symbolic Regression" by Korns DOI: 10.1007/978-1-4614-1770-5_8 """ def korns_func1(x0, x1, x2, x3, x4): return 1.57 + 24.3 * x3 def korns_func2(x0, x1, x2, x3, x4): return 0.23 + 14.2 * (x3 + x1) / (3.0 * x4) def korns_func3(x0, x1, x2, x3, x4): return -5.41 + 4.9 * (x3 - x0 + x1 / x4) / (3.0 * x4) def korns_func4(x0, x1, x2, x3, x4): return -2.3 + 0.13 * np.sin(x2) def korns_func5(x0, x1, x2, x3, x4): return 3.0 + 2.13 * np.log(x4) def korns_func6(x0, x1, x2, x3, x4): return 1.3 + 0.13 * np.sqrt(x0) def korns_func7(x0, x1, x2, x3, x4): return 213.809_408_89 - 213.809_408_89 * np.exp(-0.547_237_485_42 * x0) def korns_func8(x0, x1, x2, x3, x4): return 6.87 + 11.0 * np.sqrt(7.23 * x0 * x3 * x4) def korns_func9(x0, x1, x2, x3, x4): return np.sqrt(x0) / np.log(x1) * np.exp(x2) / x3 ** 2 def korns_func10(x0, x1, x2, x3, x4): return 0.81 + 24.3 * (2.0 * x1 + 3.0 * x2 * x3) / (4.0 * x3 ** 3 + 5.0 * x4 ** 4) def korns_func11(x0, x1, x2, x3, x4): return 6.87 + 11.0 * np.cos(7.23 * x0 ** 3) def korns_func12(x0, x1, x2, x3, x4): return 2.0 - 2.1 * np.cos(9.8 * x0) * np.sin(1.3 * x4) def korns_func13(x0, x1, x2, x3, x4): return 32.0 - 3.0 * np.tan(x0) / np.tan(x1) * np.tan(x2) / np.tan(x3) def korns_func14(x0, x1, x2, x3, x4): return 22.0 - 4.2 * (np.cos(x0) - np.tan(x1)) * np.tanh(x2) / np.sin(x3) def korns_func15(x0, x1, x2, x3, x4): return 12.0 - 6.0 * np.tan(x0) / np.exp(x1) * (np.log(x2) - np.tan(x3)) def _korns_helper(func, rng=np.random): train = generate_uniform_data_set(func, 1000, (-50, 50), rng=rng) test = generate_uniform_data_set(func, 1000, (-50, 50), rng=rng) return train, test generator_from_helper(_korns_helper) current_module = sys.modules[__name__] all_problems = {name: getattr(current_module, name) for name in locals() if "generate_korns" in name} PK!挧%reg_bench/symbolic_regression/koza.pyimport sys from functools import partial import numpy as np from .util import generate_uniform_data_set from .util import generator_from_helper from .util import poly koza_func1 = partial(poly, i=4) def koza_func2(x): return x ** 5 - 2.0 * x ** 3 + x def koza_func3(x): return x ** 6 - 2.0 * x ** 4 + x ** 2 def _koza_helper(func, rng=np.random): train = generate_uniform_data_set(func, 20, (-1, 1), rng=rng) test = generate_uniform_data_set(func, 20, (-1, 1), rng=rng) return train, test generator_from_helper(_koza_helper) current_module = sys.modules[__name__] all_problems = {name: getattr(current_module, name) for name in locals() if "generate_koza" in name} PK!*z'reg_bench/symbolic_regression/nguyen.pyimport sys from functools import partial import numpy as np from .util import generate_evenly_spaced_data_set from .util import generate_uniform_data_set from .util import generator_from_helper from .util import poly nguyen_func1 = partial(poly, i=3) nguyen_func3 = partial(poly, i=5) nguyen_func4 = partial(poly, i=6) def nguyen_func5(x): return np.sin(x ** 2) * np.cos(x) - 1.0 def nguyen_func6(x): return np.sin(x) + np.sin(x + x ** 2) def nguyen_func7(x): return np.log(x + 1) + np.log(x ** 2 + 1) def nguyen_func8(x): return np.sqrt(x) def nguyen_func9(x, y): return np.sin(x) + np.sin(y ** 2) def nguyen_func10(x, y): return 2.0 * np.sin(x) * np.cos(y) def _nguyen1_6_helper(func, rng=np.random): train = generate_uniform_data_set(func, 20, (-1, 1), rng=rng) test = generate_uniform_data_set(func, 20, (-1, 1), rng=rng) return train, test generator_from_helper(_nguyen1_6_helper, i=(1, 3, 4, 5, 6)) def generate_nguyen7(rng=np.random): train = generate_uniform_data_set(nguyen_func7, 20, (0, 2), rng=rng) test = generate_uniform_data_set(nguyen_func7, 20, (0, 2), rng=rng) return train, test def generate_nguyen8(rng=np.random): train = generate_uniform_data_set(nguyen_func8, 20, (0, 4), rng=rng) test = generate_uniform_data_set(nguyen_func8, 20, (0, 4), rng=rng) return train, test def _nguyen9_10_helper(func, rng=np.random): train = generate_uniform_data_set(func, 100, (-1, 1), rng=rng) test = generate_uniform_data_set(func, 100, (-1, 1), rng=rng) return train, test generator_from_helper(_nguyen9_10_helper, i=(9, 10)) current_module = sys.modules[__name__] all_problems = {name: getattr(current_module, name) for name in locals() if "generate_nguyen" in name} PK!D^bb&reg_bench/symbolic_regression/pagie.pyfrom .util import generate_evenly_spaced_data_set def pagie_func1(x, y): return 1.0 / x ** (-4) + 1.0 / y ** (-4) def generate_pagie1(): train = generate_evenly_spaced_data_set(pagie_func1, 0.4, (-5, 5)) test = generate_evenly_spaced_data_set(pagie_func1, 0.4, (-5, 5)) return train, test all_problems = {"pagie1": generate_pagie1} PK!гaV V %reg_bench/symbolic_regression/util.pyimport collections import inspect import sys from functools import partial from inspect import getframeinfo from inspect import getmodulename from inspect import stack from itertools import repeat import numpy as np import toolz def poly(x, i): return np.sum(x ** j for j in range(1, i + 1)) test_data = collections.namedtuple("TestData", "data target") def generate_data_set(testfunction, num_points, dist, params): dim = len(inspect.getfullargspec(testfunction).args) if isinstance(params, dict): dist_ = lambda size, params: dist(size=size, **params) else: dist_ = nd_dist_factory(dist) data = dist_(size=(dim, num_points), params=params) target = testfunction(*data) return test_data(data=data, target=target) def nd_dist_factory(dist): return lambda size, params: np.array( [dist(size=s, **p) for s, p in zip(repeat(size[1], times=size[0]), params)] ) def generate_uniform_data_set(testfunction, num_points, ranges, rng=np.random): to_dict = lambda range_: dict(low=range_[0], high=range_[1]) params = (to_dict(range_) for range_ in ranges) if toolz.isiterable(ranges[0]) else to_dict(ranges) return generate_data_set(testfunction, num_points, rng.uniform, params) def isiterable(x): try: iter(x) return True except TypeError: return False def generate_evenly_spaced_data_set(testfunction, step_sizes, ranges): dim = len(inspect.getfullargspec(testfunction).args) if len(ranges) == 2 and not isiterable(ranges[0]): ranges = repeat(ranges, times=dim) else: if dim != len(ranges): raise ValueError if isinstance(step_sizes, float): step_sizes = repeat(step_sizes, times=dim) else: if dim != len(step_sizes): raise ValueError grid = np.meshgrid( *[ np.linspace(l, u, (u - l) / step_size + 1, endpoint=True) for (l, u), step_size in zip(ranges, step_sizes) ] ) data = np.array([g.flatten() for g in grid]) return test_data(data=data, target=testfunction(*data)) def generator_from_helper(helper, shift=0, i=()): caller = getframeinfo(stack()[1][0]) # find current_module by looking up caller in stack name = getmodulename(caller.filename) current_module = [mod for mname, mod in sys.modules.items() if name == mname.split(".")[-1]][0] context = dir(current_module) for f, fname in ( (getattr(current_module, func), func) for func in context if "{}_func".format(name) in func ): f_ = partial(helper, func=f) n = int(fname.split("_func")[-1]) if n in i or not i: generator_name = "generate_{}{}".format(name, n + shift) if generator_name not in context: setattr(current_module, generator_name, f_) # register generator function in current_module PK!'c. .reg_bench/symbolic_regression/vladislavleva.pyimport sys import numpy as np from .util import generate_evenly_spaced_data_set from .util import generate_uniform_data_set def vladislavleva_func1(x, y): return np.exp(-1.0 * (x - 1) ** 2) / (1.2 + (y - 2.5) ** 2) def vladislavleva_func2(x): sx = np.sin(x) cx = np.cos(x) return np.exp(-x) * x ** 3 * cx * sx * (cx * sx ** 2 - 1.0) def vladislavleva_func3(x, y): return vladislavleva_func2(x) * (y - 5) def vladislavleva_func4(x, y, z, w, v): return 10.0 / (5 + np.sum((i - 3) ** 2 for i in [x, y, z, w, v])) def vladislavleva_func5(x, y, z): return 30 * (x - 1) * (z - 1) / (y ** 2 * (x - 10)) def vladislavleva_func6(x, y): return 6 * np.sin(x) * np.cos(y) def vladislavleva_func7(x, y): return (x - 3) * (y - 3) + 2 * np.sin((x - 4) * (y - 4)) def vladislavleva_func8(x, y): return ((x - 3) ** 4 + (y - 3) ** 3 - (y - 3)) / ((y - 2) ** 4 + 10.0) def generate_vladislavleva1(rng=np.random): train = generate_uniform_data_set(vladislavleva_func1, 100, (0.3, 4), rng=rng) test = generate_evenly_spaced_data_set(vladislavleva_func1, 0.1, (-0.2, 4.2)) return train, test def generate_vladislavleva2(): train = generate_evenly_spaced_data_set(vladislavleva_func2, 0.1, (0.05, 10.0)) test = generate_evenly_spaced_data_set(vladislavleva_func2, 0.05, (-0.5, 10.5)) return train, test def generate_vladislavleva3(): train = generate_evenly_spaced_data_set(vladislavleva_func3, [0.1, 2.0], [(0.05, 10.0), (0.05, 10.05)]) test = generate_evenly_spaced_data_set(vladislavleva_func3, [0.05, 0.5], (-0.5, 10.5)) return train, test def generate_vladislavleva4(rng=np.random): train = generate_uniform_data_set(vladislavleva_func4, 1024, (0.05, 6.05), rng=rng) test = generate_uniform_data_set(vladislavleva_func4, 5000, (-0.25, 6.35), rng=rng) return train, test def generate_vladislavleva5(rng=np.random): train = generate_uniform_data_set(vladislavleva_func5, 300, [(0.05, 2), (1, 2), (0.05, 2)], rng=rng) test = generate_evenly_spaced_data_set( vladislavleva_func5, [0.15, 0.1, 0.15], [(-0.05, 2.1), (0.95, 2.05), (-0.05, 2.1)] ) return train, test def generate_vladislavleva6(rng=np.random): train = generate_uniform_data_set(vladislavleva_func6, 30, (0.1, 5.9), rng=rng) test = generate_evenly_spaced_data_set(vladislavleva_func6, 0.02, (-0.05, 6.05)) return train, test def generate_vladislavleva7(rng=np.random): train = generate_uniform_data_set(vladislavleva_func7, 300, (0.05, 6.05), rng=rng) test = generate_uniform_data_set(vladislavleva_func7, 1000, (-0.25, 6.35), rng=rng) return train, test def generate_vladislavleva8(rng=np.random): train = generate_uniform_data_set(vladislavleva_func8, 50, (0.05, 6.05), rng=rng) test = generate_evenly_spaced_data_set(vladislavleva_func8, 0.02, (-0.25, 6.35)) return train, test current_module = sys.modules[__name__] all_problems = {name: getattr(current_module, name) for name in locals() if "generate_vladislavleva" in name} PK!Mareg_bench/utils.pydef make_register(dct): def register(arity, *tags): def inner(func): dct[func] = {"arity": arity, "tags": tags, "name": func.__name__} return func return inner return register PK!TT!reg_bench-0.0.3.dist-info/LICENSECopyright 2018 Markus Quade Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. PK!HڽTUreg_bench-0.0.3.dist-info/WHEEL A н#Z;/"d&F[xzw@Zpy3Fv]\fi4WZ^EgM_-]#0(q7PK!Hz%"reg_bench-0.0.3.dist-info/METADATA]o0+*G&v0 &ulj'Y53d_ iy5ZU'4`)YI~C Y9)Aw %D@$AP[gJ7#Bx7yƐȰ6^x}uG.-k_r~uQ%TO/ n;t ?OOyHMzMUy?$ZuAPΏNjZ&4G-ZEzr> y41GMSލǐS9b~ڛE#FXV!z UccKUp{Oeߖ.QFX%LsU[-H,A&>^N1Bo֟r`?هZaX&?spR ~?`,،2U~l$dM) *H!/0<6,>A+PK!Hk reg_bench-0.0.3.dist-info/RECORDɶH}= ކDE/PQepSTIZ9T=E.":N%HNZʑjSwcj ..9Ah(gX )߼' *pDyweBC0ˢSQU|LTmsӉ:V}}a^Og#a^q R(:K(ÛM?k]}<ICom;n\kNFŪi,H6Nꨍg"ϯC[E=mTʰzmH[LZe3V4-j ԐLc>UcvN'pC@Ws`2iu-bEQb+I$53L׊PƱ+=1)}T0}7bOk.?Bŋx)|I9l4˅8AP3?2N)DaFk&og}ϘinHSO:gN-GE0Io-%z8_BEyBClF!Wy#?E39b]>r1yO7g>9="xII7G u: (06la$ՄU;/CU`q*3_syhE"o R,w-IWS؏nwod8F̝0Tk}^#lD H4it%Mi7E=5_# CK6}O͏K?G uk[U?zݎd7#dv&*_ٰ~k$54 Ɲ]Xn<3(⠉ n̫[.-k,uʟ$3G"iƍHɲN( E5+++]U~^QF[ R{ٻxע$AlV(PK!Fcreg_bench/__init__.pyPK!JgRreg_bench/__version__.pyPK!%%reg_bench/maps/__init__.pyPK!74reg_bench/maps/maps.pyPK!F(reg_bench/ode/__init__.pyPK!~1ܻ# reg_bench/ode/integrate.pyPK!_700"reg_bench/ode/not_so_simple_ode.pyPK!fu"rreg_bench/ode/simple_ode.pyPK!MjCC)1reg_bench/symbolic_regression/__init__.pyPK!)(#4reg_bench/symbolic_regression/keijzer.pyPK!Wa&Creg_bench/symbolic_regression/korns.pyPK!挧%Kreg_bench/symbolic_regression/koza.pyPK!*z'Nreg_bench/symbolic_regression/nguyen.pyPK!D^bb&Vreg_bench/symbolic_regression/pagie.pyPK!гaV V %Wreg_bench/symbolic_regression/util.pyPK!'c. .Mcreg_bench/symbolic_regression/vladislavleva.pyPK!Maoreg_bench/utils.pyPK!TT!preg_bench-0.0.3.dist-info/LICENSEPK!HڽTUtreg_bench-0.0.3.dist-info/WHEELPK!Hz%"ureg_bench-0.0.3.dist-info/METADATAPK!Hk wreg_bench-0.0.3.dist-info/RECORDPKc{