def test_X_sparse():
from EvoDAG import RootGP
gp = RootGP(generations=1,
tournament_size=2,
popsize=10)
X1 = list(map(SparseArray.fromlist, X.T))
gp.X = X1
def test_model_graphviz():
from EvoDAG import RootGP
from EvoDAG.node import Function
import tempfile
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp = RootGP(generations=3,
tournament_size=2,
early_stopping_rounds=-1,
classifier=False,
pr_variable=1,
seed=0,
popsize=10).fit(X, y)
m = gp.model()
print(m._hist)
print(m._hist[-1].position, m._hist[-1]._variable)
with tempfile.TemporaryFile('w+') as io:
m.graphviz(io)
io.seek(0)
l = io.readlines()
cnt = len(m._hist)
for k in m._hist:
if isinstance(k, Function):
v = k._variable
if isinstance(v, list):
cnt += len(v)
else:
cnt += 1
print("".join(l))
print(cnt, len(l))
assert 2 + cnt == len(l)
def test_model_graphviz():
from EvoDAG import RootGP
from EvoDAG.node import Function
import tempfile
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp = RootGP(generations=3,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=10).fit(X, y)
m = gp.model()
print(m._hist)
print(m._hist[-1].position, m._hist[-1]._variable)
with tempfile.TemporaryFile('w+') as io:
m.graphviz(io)
io.seek(0)
l = io.readlines()
cnt = len(m._hist)
for k in m._hist:
if isinstance(k, Function):
v = k._variable
if isinstance(v, list):
cnt += len(v)
else:
cnt += 1
print("".join(l))
print(cnt, len(l))
assert 2 + cnt == len(l)
def test_X_sparse():
from EvoDAG import RootGP
from EvoDAG.sparse_array import SparseArray
gp = RootGP(generations=1,
tournament_size=2,
popsize=10)
X1 = list(map(SparseArray.fromlist, X.T))
gp.X = X1
def test_features():
from EvoDAG import RootGP
gp = RootGP(generations=1)
gp.X = X
assert gp.nvar == 4
print(gp.X)
assert isinstance(gp.X[0], Variable)
assert isinstance(gp.X[0].hy, SparseArray)
gp.Xtest = X
assert gp.X[0].hy.SSE(gp.X[0].hy_test) == 0
def test_multiclass_decision_function():
from EvoDAG import RootGP
y = cl.copy()
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=100).fit(X, y, test_set=X)
d = gp.decision_function()
assert len(d) == np.unique(y).shape[0]
def test_trace():
from EvoDAG import RootGP
from EvoDAG.node import Add
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
Add.nargs = 3
gp = RootGP(generations=np.inf,
tournament_size=2,
function_set=[Add],
classifier=False,
early_stopping_rounds=-1,
seed=0,
popsize=4)
gp.X = X[:-10]
gp.Xtest = X[-10:]
gp.y = y[:-10]
gp.create_population()
a = gp.random_offspring()
gp.population.replace(a)
print(a.position, a.variable, a._weight, gp.population.hist[0].variable)
s = gp.trace(a)
print(len(s), s)
assert a._weight.shape[0] + 1 == len(s)
def test_fitness():
from EvoDAG import RootGP
gp = RootGP(generations=1, classifier=False, popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
l = gp.random_leaf()
assert l.fitness < 0
def test_features():
from EvoDAG.sparse_array import SparseArray
from EvoDAG import RootGP
gp = RootGP(generations=1)
gp.X = X
assert gp.nvar == 4
print(gp.X)
assert isinstance(gp.X[0], Variable)
assert isinstance(gp.X[0].hy, SparseArray)
gp.Xtest = X
assert gp.X[0].hy.SSE(gp.X[0].hy_test) == 0
def create_problem_node(nargs=4, seed=0):
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=nargs, classifier=False, seed=seed)
gp.X = X
gp.Xtest = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
return gp, [gp.X[x] for x in range(nargs)]
def create_problem_node(nargs=4):
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
gp.X = X
gp.Xtest = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
return gp, [gp.X[x] for x in range(nargs)]
def test_get_params():
from EvoDAG import RootGP
# y = cl.copy()
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=100)
p = gp.get_params()
assert p['generations'] == np.inf
assert p['popsize'] == 100
assert p['seed'] == 0
def test_fitness():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
assert gp._classifier
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
l = gp.random_leaf()
assert l.fitness < 0
def test_multiclass_predict():
from EvoDAG import RootGP
y = cl.copy()
y[y == 0] = 3
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=100).fit(X, y, test_set=X)
d = gp.predict()
assert np.unique(d).shape[0] == np.unique(y).shape[0]
assert np.all(np.unique(d) == np.unique(y))
def test_get_params():
from EvoDAG import RootGP
# y = cl.copy()
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=100)
p = gp.get_params()
assert p['generations'] == np.inf
assert p['popsize'] == 100
assert p['seed'] == 0
def test_get_clone():
from EvoDAG import RootGP
# y = cl.copy()
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=100)
gp1 = gp.clone()
print(gp.popsize, gp1.popsize)
assert gp.popsize == gp1.popsize
assert gp._generations == gp1._generations
assert gp._seed == gp1._seed
def test_classification_y():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
assert gp._classifier
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
assert gp._ytr.SSE(gp.y) > 0
assert gp._ytr.sum() == 0
assert gp.y.sum() < 0
def test_create_population2():
from EvoDAG import RootGP
from EvoDAG.node import Function
gp = RootGP(generations=1, popsize=10)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
gp.create_population()
for i in gp.population.population[4:]:
assert isinstance(i, Function)
def test_get_clone():
from EvoDAG import RootGP
# y = cl.copy()
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=100)
gp1 = gp.clone()
print(gp.popsize, gp1.popsize)
assert gp.popsize == gp1.popsize
assert gp._generations == gp1._generations
assert gp._seed == gp1._seed
def test_regression():
from EvoDAG import RootGP
x = np.linspace(-1, 1, 100)
y = 4.3 * x**2 + 3.2 * x - 3.2
gp = RootGP(classifier=False, popsize=10,
generations=2).fit([SparseArray.fromlist(x)],
y,
test_set=[SparseArray.fromlist(x)])
model = gp.model()
yh = gp.predict()
assert not model._classifier
yh1 = model.predict(X=[SparseArray.fromlist(x)])
spf = SparseArray.fromlist
assert spf(yh).SSE(spf(yh1)) == 0
def test_regression():
from EvoDAG import RootGP
from EvoDAG.sparse_array import SparseArray
x = np.linspace(-1, 1, 100)
y = 4.3*x**2 + 3.2 * x - 3.2
gp = RootGP(classifier=False,
popsize=10,
generations=2).fit([SparseArray.fromlist(x)], y,
test_set=[SparseArray.fromlist(x)])
model = gp.model()
yh = gp.predict()
assert not model._classifier
yh1 = model.predict(X=[SparseArray.fromlist(x)])
spf = SparseArray.fromlist
assert spf(yh).SSE(spf(yh1)) == 0
def test_mask_vs():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
assert gp._classifier
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
m = ~ gp._mask.tonparray().astype(np.bool)
f = np.zeros(gp._mask.size())
f[y == -1] = 0.5 / (y[m] == -1).sum()
f[y == 1] = 0.5 / (y[m] == 1).sum()
f[~m] = 0
assert gp._mask_vs.SSE(SparseArray.fromlist(f)) == 0
def test_labels():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = 2
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
m = gp.model()
hy = m.predict(X=X[:-10])
print(np.unique(hy))
print(np.array([1, 2]))
assert np.all(np.unique(hy) == np.array([1, 2]))
def test_unique():
from EvoDAG import RootGP
mock = MagicMock(side_effect=RuntimeError('Mock'))
ui = RootGP.unique_individual
RootGP.unique_individual = mock
gp = RootGP(generations=np.inf,
tournament_size=2,
unique_individuals=True,
early_stopping_rounds=-1,
seed=0,
popsize=100)
try:
gp.fit(X, cl)
except RuntimeError:
pass
RootGP.unique_individual = ui
def test_ensemble_model():
from EvoDAG import RootGP
from EvoDAG.model import Ensemble
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gps = [
RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
classifier=False,
seed=seed,
popsize=10).fit(X[:-10], y[:-10], test_set=X)
for seed in range(3)
]
ens = Ensemble([gp.model() for gp in gps])
res = [gp.decision_function() for gp in gps]
res = np.median([x.full_array() for x in res], axis=0)
res = SparseArray.fromlist(res)
print(res)
# res = Add.cumsum(res) * (1 / 3.)
r2 = ens.decision_function(None)
print(res.full_array()[:10], r2.full_array()[:10])
print(res.SSE(r2))
assert res.SSE(r2) == 0
def test_unique():
from EvoDAG import RootGP
mock = MagicMock(side_effect=RuntimeError('Mock'))
ui = RootGP.unique_individual
RootGP.unique_individual = mock
gp = RootGP(generations=np.inf,
tournament_size=2,
unique_individuals=True,
multiple_outputs=True,
early_stopping_rounds=-1,
seed=0,
popsize=100)
try:
gp.fit(X, cl)
except RuntimeError:
pass
RootGP.unique_individual = ui
def test_pickle_model():
from EvoDAG import RootGP
import pickle
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
m = gp.model()
hy = gp.decision_function(X=X[-10:])
m1 = pickle.loads(pickle.dumps(m))
hy1 = m1.decision_function(X=X[-10:])
assert hy.SSE(hy1) == 0
def test_labels():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 1
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
multiple_outputs=True,
seed=0,
popsize=100).fit(X, y, test_set=X)
m = gp.model()
hy = m.predict(X=X)
print(np.unique(hy), np.unique(y))
print(np.array([1, 2]))
for k in np.unique(hy):
assert k in [1, 2]
def test_predict():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
function_set = [
x for x in RootGP()._function_set if x.regression and x.nargs
]
gp = RootGP(generations=np.inf,
tournament_size=2,
function_set=function_set,
early_stopping_rounds=-1,
classifier=False,
remove_raw_inputs=False,
seed=0,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
es = gp.population.estopping
assert gp.decision_function().SSE(es.hy_test) == 0
hy_test = es.hy_test
assert gp.decision_function(X=X[-10:]).SSE(hy_test) == 0
hy = gp.decision_function(X=X[-10:])
_ = gp.predict(X=X[-10:])
assert SparseArray.fromlist(_).SSE(hy) == 0
assert len(gp.Xtest)
def test_fit():
from EvoDAG import RootGP
function_set = [x for x in RootGP()._function_set if x.regression]
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
function_set=function_set,
classifier=False,
seed=0,
popsize=4).fit(X, y, test_set=X)
assert np.isfinite(gp.population.estopping.fitness)
assert np.isfinite(gp.population.estopping.fitness_vs)
assert gp.population.estopping.hy.isfinite()
assert len(gp.population.hist) > 4
def test_population_as_parameter():
class Mock(object):
def __init__(self, *args, **kwargs):
raise RuntimeError('Mock')
from EvoDAG import RootGP
mock = Mock
gp = RootGP(generations=np.inf,
population_class=mock,
tournament_size=2,
unique_individuals=True,
early_stopping_rounds=-1,
seed=0,
popsize=100)
try:
gp.fit(X, cl)
assert False
except RuntimeError:
pass
def test_RSE():
from EvoDAG import RootGP
from EvoDAG.utils import RSE as rse
x = np.linspace(-1, 1, 100)
y = 4.3 * x**2 + 3.2 * x - 3.2
y[10:12] = 0
gp = RootGP(classifier=False, popsize=10,
generations=2).fit([SparseArray.fromlist(x)],
y,
test_set=[SparseArray.fromlist(x)])
model = gp.model()
yh = gp.predict()
assert not model._classifier
model.predict(X=[SparseArray.fromlist(x)])
gp._mask = SparseArray.fromlist([2] * yh.shape[0])
gp._bagging_fitness.fitness_vs(model._hist[-1])
print(rse(y, yh), model._hist[-1].fitness_vs)
assert_almost_equals(rse(y, yh), -model._hist[-1].fitness_vs)
def test_regression_y():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4, classifier=False)
assert not gp._classifier
gp.X = X
gp.y = cl.copy()
assert gp._ytr.SSE(gp.y) > 0
gp = RootGP(generations=1, popsize=4, classifier=False, tr_fraction=1.0)
gp.X = X
gp.y = cl.copy()
assert gp._ytr.SSE(gp.y) == 0
def test_random_leaf():
from EvoDAG import RootGP
gp = RootGP(generations=1, classifier=False, popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
randint = np.random.randint
mock = MagicMock(return_value=0)
np.random.randint = mock
mask = tonparray(gp._mask).astype(np.bool)
weight = np.linalg.lstsq(X[mask, 0][:, np.newaxis], y[mask])[0][0]
var = gp.random_leaf()
assert isinstance(var, Variable)
print(weight, var.weight)
assert_almost_equals(weight, var.weight)
np.random.randint = randint
def test_pickle_model():
from EvoDAG import RootGP
import pickle
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
multiple_outputs=True,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
m = gp.model()
hy = gp.decision_function(X=X[-10:])
m1 = pickle.loads(pickle.dumps(m))
hy1 = m1.decision_function(X=X[-10:])
for a, b in zip(hy, hy1):
assert a.SSE(b) == 0
def test_predict():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=0,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
es = gp.population.estopping
assert gp.decision_function().SSE(es.hy_test.boundaries()) == 0
hy_test = es.hy_test.boundaries()
assert gp.decision_function(X=X[-10:]).SSE(hy_test) == 0
hy = gp.decision_function(X=X[-10:])
_ = gp.predict(X=X[-10:])
assert SparseArray.fromlist(_).SSE(hy.sign()) == 0
assert len(gp.Xtest)
def test_model_hist():
from EvoDAG import RootGP
from EvoDAG.base import Model
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
seed=1,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
hist = gp.population.hist
trace = gp.trace(gp.population.estopping)
a = hist[trace[-1]].variable
m = Model(trace, hist)
print((m._map, a, m._hist[-1].variable))
for v1, v2 in zip(a, m._hist[-1].variable):
assert m._map[v1] == v2
def test_best_so_far():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
randint = np.random.randint
mock = MagicMock()
mock.side_effect = list(range(gp.popsize))
np.random.randint = mock
gp.create_population()
p = gp.population.population
index = np.argsort([x.fitness for x in p])[-1]
print(p[index].fitness, gp.population.bsf.fitness)
assert gp.population.bsf == p[index]
np.random.randint = randint
def test_population_as_parameter():
class Mock(object):
def __init__(self, *args, **kwargs):
raise RuntimeError('Mock')
from EvoDAG import RootGP
mock = Mock
gp = RootGP(generations=np.inf,
population_class=mock,
tournament_size=2,
multiple_outputs=True,
unique_individuals=True,
early_stopping_rounds=-1,
seed=0,
popsize=100)
try:
gp.fit(X, cl)
assert False
except RuntimeError:
pass
def test_random_leaf():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4, tr_fraction=1)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
randint = np.random.randint
mock = MagicMock(return_value=0)
np.random.randint = mock
mask = gp._mask.tonparray().astype(np.bool)
weight = np.linalg.lstsq(X[mask, 0][:, np.newaxis], y[mask])[0][0]
var = gp.random_leaf()
assert isinstance(var, Variable)
print(weight, var.weight)
assert_almost_equals(weight, var.weight[0])
np.random.randint = randint
def create_problem_node2(nargs=4, seed=0):
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=nargs, multiple_outputs=True, seed=seed)
gp.X = X
gp.Xtest = X
y = cl.copy()
gp.nclasses(y)
gp.y = y
return gp, [gp.X[x] for x in range(nargs)]
def test_variable():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
gp.X = X
Xtest = [x for x in X]
Xtest[0] = Xtest[0] + np.inf
gp.Xtest = Xtest
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
randint = np.random.randint
mock = MagicMock()
mock.side_effect = list(range(gp.popsize))
np.random.randint = mock
var = gp.random_leaf()
assert var.isfinite()
assert var.hy.isfinite()
np.random.randint = randint
def test_create_population():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
gp.create_population()
assert_almost_equals(gp.population.popsize, gp.popsize)
# a = map(lambda (x, y): x == y, zip(gp.population.population,
# gp.population._hist))
a = [x == y1 for x, y1 in zip(gp.population.population,
gp.population._hist)]
assert np.all(a)
l = [x.variable for x in gp.population.population]
l.sort()
# assert np.all(map(lambda (x, y): x == y, enumerate(l)))
assert np.all([x == y1 for x, y1 in enumerate(l)])
def test_fname():
from EvoDAG.node import Add
from EvoDAG import RootGP
x = np.linspace(-1, 1, 100)
y = 4.3 * x**2 + 3.2 * x - 3.2
Add.nargs = 10
gp = RootGP(classifier=False, popsize=10,
generations=2).fit([SparseArray.fromlist(x)],
y,
test_set=[SparseArray.fromlist(x)])
assert gp.signature.count('Ad10') == 1
def test_early_stopping():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
randint = np.random.randint
mock = MagicMock()
mock.side_effect = list(range(gp.popsize))
np.random.randint = mock
gp.create_population()
p = gp.population.population
fit = np.array([x.fitness_vs for x in p])
best = fit.max()
index = np.where(best == fit)[0][0]
assert gp.population.estopping == p[index]
np.random.randint = randint
def test_tournament_negative():
from EvoDAG import RootGP
gp = RootGP(generations=1,
tournament_size=4,
popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
randint = np.random.randint
mock = MagicMock()
mock.side_effect = list(range(gp.popsize))
np.random.randint = mock
gp.create_population()
j = gp.population.tournament(negative=True)
index = np.argsort([x.fitness for x in gp.population.population])[0]
assert j == index
np.random.randint = randint
def test_logging():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
classifier=False,
seed=0,
popsize=10).fit(X, y, test_set=X)
def test_random_selection():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
RootGP(generations=np.inf,
tournament_size=1,
early_stopping_rounds=-1,
classifier=False,
seed=0,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
def test_random_leaf_inf():
from EvoDAG import RootGP
gp = RootGP(generations=1, classifier=False, popsize=4, tr_fraction=1)
Xc = [x for x in X]
Xc[0] = Xc[0] + np.inf
gp.X = Xc
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
randint = np.random.randint
mock = MagicMock()
mock.side_effect = list(range(2))
np.random.randint = mock
gp.random_leaf()
try:
assert mock()
assert False
except Exception:
pass
np.random.randint = randint
def test_class_values():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 0
y[~mask] = -1
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=-1,
classifier=True,
multiple_outputs=True,
seed=0,
popsize=10).fit(X[:-10], y[:-10], test_set=X[-10:])
assert np.all(gp._labels == np.array([-1, 0]))
def test_es_extra_test():
from EvoDAG import RootGP
x = np.linspace(-1, 1, 100)
y = 4.3 * x**2 + 3.2 * x - 3.2
es_extra_test = RootGP.es_extra_test
RootGP.es_extra_test = MagicMock(side_effect=RuntimeError('Mock'))
try:
RootGP(classifier=False, popsize=10,
generations=2).fit([SparseArray.fromlist(x)],
y,
test_set=[SparseArray.fromlist(x)])
assert False
except RuntimeError:
RootGP.es_extra_test = es_extra_test
def test_fit_stopping_criteria_gens():
from EvoDAG import RootGP
from EvoDAG.node import Add
Add.nargs = 2
function_set = [x for x in RootGP()._function_set if x.regression]
gp = RootGP(generations=2,
early_stopping_rounds=None,
tournament_size=2,
function_set=function_set,
classifier=False,
seed=1,
popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
gp.create_population()
for i in range(gp.popsize):
assert not gp.stopping_criteria()
a = gp.random_offspring()
gp.population.replace(a)
assert gp.stopping_criteria()
def create_problem_node2(nargs=4, seed=0):
from EvoDAG import RootGP
from test_root import X, cl
import numpy as np
gp = RootGP(generations=1, popsize=nargs, multiple_outputs=True, seed=seed)
X1 = np.concatenate((X, np.atleast_2d(np.zeros(X.shape[0])).T), axis=1)
for i in range(10, 20):
X1[i, -1] = 1
gp.X = X1
gp.Xtest = X1
y = cl.copy()
gp.nclasses(y)
gp.y = y
return gp, [gp.X[x] for x in range(nargs)]
def test_infite_evolution():
from EvoDAG import RootGP
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
try:
RootGP(generations=np.inf,
tournament_size=2,
tr_fraction=1,
early_stopping_rounds=-1,
seed=0,
popsize=10).fit(X, y, test_set=X)
assert False
except RuntimeError:
pass
def test_fit_stopping_criteria_estopping():
from EvoDAG import RootGP
function_set = [x for x in RootGP()._function_set if x.regression]
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=4,
function_set=function_set,
classifier=False,
seed=0,
popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
gp.create_population()
while not gp.stopping_criteria():
a = gp.random_offspring()
gp.population.replace(a)
print(len(gp.population.hist) - gp.population.estopping.position)
assert (len(gp.population.hist) - gp.population.estopping.position) <= 9
def test_regression_y():
from EvoDAG import RootGP
gp = RootGP(generations=1, popsize=4, classifier=False)
assert not gp._classifier
gp.X = X
gp.y = cl
assert gp._ytr.SSE(gp.y) > 0
gp = RootGP(generations=1, popsize=4, classifier=False, tr_fraction=1.0)
gp.X = X
gp.y = cl
assert gp._ytr.SSE(gp.y) == 0
def test_regression():
from EvoDAG import RootGP
from EvoDAG.model import Ensemble
x = np.linspace(-1, 1, 100)
y = 4.3 * x**2 + 3.2 * x - 3.2
gps = [
RootGP(classifier=False, seed=seed, popsize=10,
generations=2).fit([SparseArray.fromlist(x)],
y,
test_set=[SparseArray.fromlist(x)])
for seed in range(3)
]
ens = Ensemble([gp.model() for gp in gps])
hy = np.median([gp.predict() for gp in gps], axis=0)
hy1 = ens.predict(X=[SparseArray.fromlist(x)])
print(hy, hy1)
assert np.all(hy == hy1)
def test_fit_stopping_criteria_gens():
from EvoDAG import RootGP
from EvoDAG.node import Add
Add.nargs = 2
gp = RootGP(generations=2,
early_stopping_rounds=None,
tournament_size=2,
seed=1,
popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
gp.create_population()
for i in range(gp.popsize):
assert not gp.stopping_criteria()
a = gp.random_offspring()
gp.population.replace(a)
assert gp.stopping_criteria()
def test_fit_stopping_criteria_estopping():
from EvoDAG import RootGP
gp = RootGP(generations=np.inf,
tournament_size=2,
early_stopping_rounds=4,
seed=0,
popsize=4)
gp.X = X
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
gp.y = y
gp.create_population()
while not gp.stopping_criteria():
a = gp.random_offspring()
gp.population.replace(a)
print(len(gp.population.hist) - gp.population.estopping.position)
assert (len(gp.population.hist) - gp.population.estopping.position) <= 9
def test_trace():
from EvoDAG import RootGP
from EvoDAG.node import Add
y = cl.copy()
mask = y == 0
y[mask] = 1
y[~mask] = -1
Add.nargs = 3
gp = RootGP(generations=np.inf,
tournament_size=2,
function_set=[Add],
early_stopping_rounds=-1,
seed=0,
popsize=4)
gp.X = X[:-10]
gp.Xtest = X[-10:]
gp.y = y[:-10]
gp.create_population()
a = gp.random_offspring()
gp.population.replace(a)
print(a.position, a.variable, a._weight, gp.population.hist[0].variable)
s = gp.trace(a)
assert len(s) == 4
