Example #1
0
def test_indindividual_decision_function():
    Add.nargs = 2
    Mul.nargs = 2
    vars = Model.convert_features(X)
    for x in vars:
        x._eval_ts = x._eval_tr.copy()
    vars = [Variable(k, weight=np.ones(1)) for k in range(len(vars))]
    for i in range(len(vars)):
        ind = Individual([vars[i]])
        ind.decision_function(X)
        hy = tonparray(ind._ind[0].hy)
        [assert_almost_equals(a, b) for a, b in zip(X[:, i], hy)]
    ind = Individual([
        Sin(0, weight=np.ones(1)),
        Add(range(2), np.ones(2)), vars[0], vars[-1]
    ])
    ind.decision_function(X)
    print(ind._ind[0].hy, ind._ind[1].hy)
    hy = tonparray(ind._ind[0].hy)
    y = np.sin(X[:, 0] + X[:, -1])
    [assert_almost_equals(a, b) for a, b in zip(y, hy)]
    y = np.sin((X[:, 0] + X[:, 1]) * X[:, 0] + X[:, 2])
    ind = Individual([
        Sin(0, weight=1),
        Add(range(2), weight=np.ones(2)),
        Mul(range(2), weight=1),
        Add(range(2), weight=np.ones(2)), vars[0], vars[1], vars[0], vars[2]
    ])
    ind.decision_function(X)
    # assert v.hy.SSE(v.hy_test) == 0
    hy = tonparray(ind._ind[0].hy)
    [assert_almost_equals(a, b) for a, b in zip(hy, y)]
    default_nargs()
Example #2
0
def test_compute_weight():
    gp, args = create_problem_node()
    mask = SparseArray.fromlist(np.ones(len(gp._mask)))
    n = Add(list(range(len(args))), ytr=gp._ytr, mask=mask)
    D = np.array([tonparray(i.hy) for i in args]).T
    coef = n.compute_weight([x.hy for x in args])
    r = np.linalg.lstsq(D, tonparray(gp._ytr))[0]
    [assert_almost_equals(a, b) for a, b in zip(coef, r)]
Example #3
0
def test_node_hash():
    from EvoDAG.node import Add, Mul
    add = Add([21, 3])
    sets = set()
    sets.add(add.signature())
    add2 = Add([21, 3])
    assert add2.signature() in sets
    assert Add([3, 21]).signature() in sets
    assert Mul([2, 3]).signature() == Mul([3, 2]).signature()
Example #4
0
def test_node_add():
    gp, args = create_problem_node()
    n = Add(list(range(len(args))), ytr=gp._ytr, mask=gp._mask)
    coef = n.compute_weight([x.hy for x in args])
    assert n.eval(args)
    # a = map(lambda (a, b): a.hy * b, zip(args, coef))
    a = [a.hy * b for a, b in zip(args, coef)]
    r = n.cumsum(a)
    assert n.hy.SSE(r) == 0
    assert n.hy_test.SSE(r) == 0
Example #5
0
def test_node_tostore():
    gp, args = create_problem_node(nargs=4)
    Add.nargs = 4
    n = Add(list(range(len(args))), ytr=gp._ytr, mask=gp._mask)
    n.position = 10
    assert n.eval(args)
    n1 = n.tostore()
    assert n1.nargs == n.nargs
    assert n1.position == n.position
    assert np.all(n1.weight == n.weight)
    assert n1.hy is None
Example #6
0
def test_node_tostore():
    gp, args = create_problem_node(nargs=4)
    Add.nargs = 4
    n = Add(list(range(len(args))), ytr=gp._ytr, mask=gp._mask)
    n.position = 10
    assert n.eval(args)
    n1 = n.tostore()
    assert n1.nargs == n.nargs
    assert n1.position == n.position
    assert np.all(n1.weight == n.weight)
    assert n1.hy is None
Example #7
0
def test_node_pickle():
    import pickle
    import tempfile
    gp, args = create_problem_node()
    n = Add(list(range(len(args))), ytr=gp._ytr, mask=gp._mask)
    n.position = 10
    assert n.eval(args)
    with tempfile.TemporaryFile('w+b') as io:
        pickle.dump(n, io)
        io.seek(0)
        n1 = pickle.load(io)
        assert n1._mask.SSE(n._mask) == 0
Example #8
0
def test_node_pickle():
    import pickle
    import tempfile
    gp, args = create_problem_node()
    n = Add(list(range(len(args))), ytr=gp._ytr, mask=gp._mask)
    n.position = 10
    assert n.eval(args)
    with tempfile.TemporaryFile('w+b') as io:
        pickle.dump(n, io)
        io.seek(0)
        n1 = pickle.load(io)
        assert n1._mask.SSE(n._mask) == 0
Example #9
0
def test_node_add():
    gp, args = create_problem_node()
    n = Add(list(range(len(args))), ytr=gp._ytr, mask=gp._mask)
    D = np.array([tonparray(i.hy) for i in args]).T
    coef = n.compute_weight([x.hy for x in args])
    assert n.eval(args)
    # a = map(lambda (a, b): a.hy * b, zip(args, coef))
    a = [_a.hy * b for _a, b in zip(args, coef)]
    r = n.cumsum(a)
    print((D * coef).sum(axis=1)[:4], "*")
    print(tonparray(n.hy)[:4])
    print(tonparray(r)[:4])
    print(tonparray(gp._mask)[:4])
    assert n.hy.SSE(r) == 0
    assert n.hy_test.SSE(r) == 0
Example #10
0
def test_node_hash():
    from EvoDAG.node import Add, Mul
    add = Add([21, 3])
    sets = set()
    sets.add(add.signature())
    add2 = Add([21, 3])
    assert add2.signature() in sets
    assert Add([3, 21]).signature() in sets
    assert Mul([2, 3]).signature() == Mul([3, 2]).signature()
Example #11
0
def test_BER():
    from EvoDAG.node import Add
    from EvoDAG import RootGP
    from EvoDAG.utils import BER
    gp = RootGP(generations=1, popsize=4, multiple_outputs=True)
    assert gp._classifier
    gp.X = X
    y = cl.copy()
    gp.nclasses(y)
    gp.y = y
    m = np.sign(tonparray(gp._mask_ts)).astype(np.bool)
    v = gp.random_leaf()
    v1 = gp.random_leaf()
    v1 = gp.random_leaf()
    a = Add([0, 1], ytr=gp._ytr, mask=gp._mask)
    a.eval([v, v1])
    hy = SparseArray.argmax(a.hy)
    b = BER(y[m], tonparray(hy)[m])
    gp._bagging_fitness.fitness(a)
    print(b, a.fitness * 100)
    assert_almost_equals(b, -a.fitness * 100)
Example #12
0
def test_BER():
    from EvoDAG.node import Add
    from EvoDAG import RootGP
    from EvoDAG.utils import BER
    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)
    v = gp.random_leaf()
    v1 = gp.random_leaf()
    v1 = gp.random_leaf()
    a = Add([0, 1], ytr=gp._ytr, mask=gp._mask)
    a.eval([v, v1])
    hy = a.hy.sign()
    b = BER(y[m], hy.tonparray()[m])
    gp.fitness_vs(a)
    print(b, a.fitness_vs * 100)
    assert_almost_equals(b, -a.fitness_vs * 100)
Example #13
0
def test_ensemble():
    from EvoDAG import RootGP
    from EvoDAG.model import Ensemble
    from EvoDAG.node import Add
    y = cl.copy()
    gps = [RootGP(generations=np.inf,
                  tournament_size=2,
                  early_stopping_rounds=-1,
                  seed=seed,
                  popsize=10).fit(X[:-10],
                                  y[:-10],
                                  test_set=X)
           for seed in range(2, 5)]
    ens = Ensemble([gp.model() for gp in gps])
    res = [gp.decision_function() for gp in gps]
    res = [Add.cumsum([x[j] for x in res]) for j in range(3)]
    res = [x / 3. for x in res]
    r2 = ens.decision_function(None)
    for a, b in zip(res, r2):
        assert a.SSE(b) == 0
    r2 = ens.predict(None)
Example #14
0
def test_ensemble():
    from EvoDAG import RootGP
    from EvoDAG.model import Ensemble
    from EvoDAG.node import Add
    y = cl.copy()
    gps = [
        RootGP(generations=np.inf,
               tournament_size=2,
               early_stopping_rounds=-1,
               seed=seed,
               multiple_outputs=True,
               popsize=10).fit(X[:-10], y[:-10], test_set=X)
        for seed in range(2, 5)
    ]
    ens = Ensemble([gp.model() for gp in gps])
    res = [gp.decision_function() for gp in gps]
    res = [Add.cumsum([x[j] for x in res]) for j in range(3)]
    res = [x * (1 / 3.) for x in res]
    r2 = ens.decision_function(None)
    for a, b in zip(res, r2):
        print(a.SSE(b), a.data, b.data, b.full_array())
        assert a.SSE(b) == 0
Example #15
0
def test_Add_multiple_output():
    from EvoDAG.node import Variable
    gp, args = create_problem_node(nargs=4, seed=0)
    gp2, _ = create_problem_node(nargs=4, seed=1)
    ytr = [gp._ytr, gp._ytr]
    mask = [gp._mask, gp2._mask]
    vars = [Variable(k, ytr=ytr, mask=mask) for k in range(len(args))]
    [x.eval(args) for x in vars]
    add = Add(range(len(vars)), ytr=ytr, mask=mask)
    assert add.eval(vars)
    gp, args = create_problem_node(nargs=4, seed=0)
    vars = [Variable(k, ytr=gp._ytr, mask=gp._mask) for k in range(len(args))]
    [x.eval(args) for x in vars]
    add2 = Add(range(len(vars)), ytr=gp._ytr, mask=gp._mask)
    assert add2.eval(vars)
    assert add2.hy.SSE(add.hy[0]) == 0
    assert add2.hy_test.SSE(add.hy_test[0]) == 0
Example #16
0
def test_ensemble_model():
    from EvoDAG import RootGP
    from EvoDAG.model import Ensemble
    from EvoDAG.node import Add
    y = cl.copy()
    mask = y == 0
    y[mask] = 1
    y[~mask] = -1
    gps = [RootGP(generations=np.inf,
                  tournament_size=2,
                  early_stopping_rounds=-1,
                  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 = Add.cumsum(res) / 3
    r2 = ens.decision_function(None)
    assert res.SSE(r2) == 0
    a = SparseArray.fromlist(ens.predict(None))
    assert r2.sign().SSE(a) == 0
Example #17
0
def test_Add_multiple_output2():
    from EvoDAG.node import Variable
    gp, args = create_problem_node(nargs=4, seed=0)
    for i in args:
        i.hy_test = None
    gp2, _ = create_problem_node(nargs=4, seed=1)
    ytr = [gp._ytr, gp._ytr]
    mask = [gp._mask, gp2._mask]
    vars = [Variable(k, ytr=ytr, mask=mask) for k in range(len(args))]
    [x.eval(args) for x in vars]
    add = Add(range(len(vars)), ytr=ytr, mask=mask)
    assert add.eval(vars)
    vars = [Variable(k, ytr=gp._ytr, mask=gp._mask) for k in range(len(args))]
    [x.eval(args) for x in vars]
    add2 = Add(range(len(vars)), ytr=gp._ytr, mask=gp._mask)
    assert add2.eval(vars)
    assert add2.hy.SSE(add.hy[0]) == 0
    assert isinstance(add.weight, list) and len(add.weight) == 2
    assert isinstance(add2.weight, np.ndarray)