Ejemplo n.º 1
0
def test_construction(x1, x2):
    k = EQ()

    k(x1)
    k(x1, x2)

    k.elwise(x1)
    k.elwise(x1, x2)

    # Test `MultiInput` construction.
    approx(
        k(MultiInput(x1, x2)),
        B.concat2d([k(x1, x1), k(x1, x2)], [k(x2, x1), k(x2, x2)]),
    )
    approx(k(x1, MultiInput(x1, x2)), B.concat(k(x1, x1), k(x1, x2), axis=1))
    approx(k(MultiInput(x1, x2), x2), B.concat(k(x1, x2), k(x2, x2), axis=0))

    approx(
        k.elwise(MultiInput(x1, x2)),
        B.concat(k.elwise(x1, x1), k.elwise(x2, x2), axis=0),
    )
    with pytest.raises(ValueError):
        k.elwise(MultiInput(x1), MultiInput(x1, x2))
    with pytest.raises(ValueError):
        k.elwise(x1, MultiInput(x1, x2))
    with pytest.raises(ValueError):
        k.elwise(MultiInput(x1, x2), x2)
Ejemplo n.º 2
0
def test_momean(x):
    prior = Measure()
    p1 = GP(lambda x: 2 * x, 1 * EQ(), measure=prior)
    p2 = GP(1, 2 * EQ().stretch(2), measure=prior)

    m = MultiOutputMean(prior, p1, p2)
    ms = prior.means

    # Check representation.
    assert str(m) == "MultiOutputMean(<lambda>, 1)"

    # Check computation.
    approx(m(x), B.concat(ms[p1](x), ms[p2](x), axis=0))
    approx(m(p1(x)), ms[p1](x))
    approx(m(p2(x)), ms[p2](x))
    approx(m(MultiInput(p2(x), p1(x))), B.concat(ms[p2](x), ms[p1](x), axis=0))
Ejemplo n.º 3
0
def test_momean():
    m = Graph()
    p1 = GP(1 * EQ(), lambda x: 2 * x, graph=m)
    p2 = GP(2 * EQ().stretch(2), 1, graph=m)

    mom = MultiOutputMean(p1, p2)
    ms = m.means

    x = np.linspace(0, 1, 10)

    assert str(mom) == 'MultiOutputMean(<lambda>, 1)'

    allclose(mom(x), np.concatenate([ms[p1](x), ms[p2](x)], axis=0))
    allclose(mom(p1(x)), ms[p1](x))
    allclose(mom(p2(x)), ms[p2](x))
    allclose(mom(MultiInput(p2(x), p1(x))),
             np.concatenate([ms[p2](x), ms[p1](x)], axis=0))
Ejemplo n.º 4
0
def test_mokernel():
    m = Graph()
    p1 = GP(1 * EQ(), graph=m)
    p2 = GP(2 * EQ().stretch(2), graph=m)

    mok = MultiOutputKernel(p1, p2)
    ks = m.kernels

    x1 = np.linspace(0, 1, 10)
    x2 = np.linspace(1, 2, 5)
    x3 = np.linspace(1, 2, 10)

    yield eq, str(mok), 'MultiOutputKernel(EQ(), 2 * (EQ() > 2))'

    # `B.Numeric` versus `B.Numeric`:
    yield assert_allclose, mok(x1, x2), \
          np.concatenate([np.concatenate([dense(ks[p1, p1](x1, x2)),
                                          dense(ks[p1, p2](x1, x2))],
                                         axis=1),
                          np.concatenate([dense(ks[p2, p1](x1, x2)),
                                          dense(ks[p2, p2](x1, x2))],
                                         axis=1)], axis=0)
    yield assert_allclose, mok.elwise(x1, x3), \
          np.concatenate([ks[p1, p1].elwise(x1, x3),
                          ks[p2, p2].elwise(x1, x3)], axis=0)

    # `B.Numeric` versus `At`:
    yield assert_allclose, mok(p1(x1), x2), \
          np.concatenate([dense(ks[p1, p1](x1, x2)),
                          dense(ks[p1, p2](x1, x2))], axis=1)
    yield assert_allclose, mok(p2(x1), x2), \
          np.concatenate([dense(ks[p2, p1](x1, x2)),
                          dense(ks[p2, p2](x1, x2))], axis=1)
    yield assert_allclose, mok(x1, p1(x2)), \
          np.concatenate([dense(ks[p1, p1](x1, x2)),
                          dense(ks[p2, p1](x1, x2))], axis=0)
    yield assert_allclose, mok(x1, p2(x2)), \
          np.concatenate([dense(ks[p1, p2](x1, x2)),
                          dense(ks[p2, p2](x1, x2))], axis=0)
    yield raises, ValueError, lambda: mok.elwise(x1, p2(x3))
    yield raises, ValueError, lambda: mok.elwise(p1(x1), x3)

    # `At` versus `At`:
    yield assert_allclose, mok(p1(x1), p1(x2)), ks[p1](x1, x2)
    yield assert_allclose, mok(p1(x1), p2(x2)), ks[p1, p2](x1, x2)
    yield assert_allclose, mok.elwise(p1(x1), p1(x3)), ks[p1].elwise(x1, x3)
    yield assert_allclose, mok.elwise(p1(x1), p2(x3)), ks[p1,
                                                          p2].elwise(x1, x3)

    # `MultiInput` versus `MultiInput`:
    yield assert_allclose, mok(MultiInput(p2(x1), p1(x2)),
                               MultiInput(p2(x1))), \
          np.concatenate([dense(ks[p2, p2](x1, x1)),
                          dense(ks[p1, p2](x2, x1))], axis=0)
    yield raises, ValueError, \
          lambda: mok.elwise(MultiInput(p2(x1), p1(x3)), MultiInput(p2(x1)))
    yield assert_allclose, mok.elwise(MultiInput(p2(x1), p1(x3)),
                                      MultiInput(p2(x1), p1(x3))), \
          np.concatenate([ks[p2, p2].elwise(x1, x1),
                          ks[p1, p1].elwise(x3, x3)], axis=0)

    # `MultiInput` versus `At`:
    yield assert_allclose, mok(MultiInput(p2(x1), p1(x2)),
                               p2(x1)), \
          np.concatenate([dense(ks[p2, p2](x1, x1)),
                          dense(ks[p1, p2](x2, x1))], axis=0)
    yield assert_allclose, mok(p2(x1),
                               MultiInput(p2(x1), p1(x2))), \
          np.concatenate([dense(ks[p2, p2](x1, x1)),
                          dense(ks[p2, p1](x1, x2))], axis=1)
    yield raises, ValueError, \
          lambda: mok.elwise(MultiInput(p2(x1), p1(x3)), p2(x1))
    yield raises, ValueError, \
          lambda: mok.elwise(p2(x1), MultiInput(p2(x1), p1(x3)))
Ejemplo n.º 5
0
def test_mokernel(x1, x2, x3):
    m = Measure()
    p1 = GP(1 * EQ(), measure=m)
    p2 = GP(2 * EQ().stretch(2), measure=m)

    k = MultiOutputKernel(m, p1, p2)
    ks = m.kernels

    # Check representation.
    assert str(k) == "MultiOutputKernel(EQ(), 2 * (EQ() > 2))"

    # Input versus input:
    approx(
        k(x1, x2),
        B.concat2d(
            [ks[p1, p1](x1, x2), ks[p1, p2](x1, x2)],
            [ks[p2, p1](x1, x2), ks[p2, p2](x1, x2)],
        ),
    )
    approx(
        k.elwise(x1, x3),
        B.concat(ks[p1, p1].elwise(x1, x3), ks[p2, p2].elwise(x1, x3), axis=0),
    )

    # Input versus `FDD`:
    approx(k(p1(x1), x2),
           B.concat(ks[p1, p1](x1, x2), ks[p1, p2](x1, x2), axis=1))
    approx(k(p2(x1), x2),
           B.concat(ks[p2, p1](x1, x2), ks[p2, p2](x1, x2), axis=1))
    approx(k(x1, p1(x2)),
           B.concat(ks[p1, p1](x1, x2), ks[p2, p1](x1, x2), axis=0))
    approx(k(x1, p2(x2)),
           B.concat(ks[p1, p2](x1, x2), ks[p2, p2](x1, x2), axis=0))
    with pytest.raises(ValueError):
        k.elwise(x1, p2(x3))
    with pytest.raises(ValueError):
        k.elwise(p1(x1), x3)

    # `FDD` versus `FDD`:
    approx(k(p1(x1), p1(x2)), ks[p1](x1, x2))
    approx(k(p1(x1), p2(x2)), ks[p1, p2](x1, x2))
    approx(k.elwise(p1(x1), p1(x3)), ks[p1].elwise(x1, x3))
    approx(k.elwise(p1(x1), p2(x3)), ks[p1, p2].elwise(x1, x3))

    # `MultiInput` versus input:
    approx(
        k(MultiInput(p2(x1), p1(x2)), x1),
        B.concat2d(
            [ks[p2, p1](x1, x1), ks[p2, p2](x1, x1)],
            [ks[p1, p1](x2, x1), ks[p1, p2](x2, x1)],
        ),
    )
    approx(
        k(x1, MultiInput(p2(x1), p1(x2))),
        B.concat2d(
            [ks[p1, p2](x1, x1), ks[p1, p1](x1, x2)],
            [ks[p2, p2](x1, x1), ks[p2, p1](x1, x2)],
        ),
    )
    with pytest.raises(ValueError):
        k.elwise(MultiInput(p2(x1), p1(x3)), p2(x1))
    with pytest.raises(ValueError):
        k.elwise(p2(x1), MultiInput(p2(x1), p1(x3)))

    # `MultiInput` versus `FDD`:
    approx(
        k(MultiInput(p2(x1), p1(x2)), p2(x1)),
        B.concat(ks[p2, p2](x1, x1), ks[p1, p2](x2, x1), axis=0),
    )
    approx(
        k(p2(x1), MultiInput(p2(x1), p1(x2))),
        B.concat(ks[p2, p2](x1, x1), ks[p2, p1](x1, x2), axis=1),
    )
    with pytest.raises(ValueError):
        k.elwise(MultiInput(p2(x1), p1(x3)), p2(x1))
    with pytest.raises(ValueError):
        k.elwise(p2(x1), MultiInput(p2(x1), p1(x3)))

    # `MultiInput` versus `MultiInput`:
    approx(
        k(MultiInput(p2(x1), p1(x2)), MultiInput(p2(x1))),
        B.concat(ks[p2, p2](x1, x1), ks[p1, p2](x2, x1), axis=0),
    )
    with pytest.raises(ValueError):
        k.elwise(MultiInput(p2(x1), p1(x3)), MultiInput(p2(x1)))
    approx(
        k.elwise(MultiInput(p2(x1), p1(x3)), MultiInput(p2(x1), p1(x3))),
        B.concat(ks[p2, p2].elwise(x1, x1), ks[p1, p1].elwise(x3, x3), axis=0),
    )
Ejemplo n.º 6
0
def test_mokernel():
    m = Graph()
    p1 = GP(1 * EQ(), graph=m)
    p2 = GP(2 * EQ().stretch(2), graph=m)

    mok = MultiOutputKernel(p1, p2)
    ks = m.kernels

    x1 = np.linspace(0, 1, 10)
    x2 = np.linspace(1, 2, 5)
    x3 = np.linspace(1, 2, 10)

    assert str(mok) == 'MultiOutputKernel(EQ(), 2 * (EQ() > 2))'

    # `B.Numeric` versus `B.Numeric`:
    allclose(
        mok(x1, x2),
        np.concatenate([
            np.concatenate(
                [B.dense(ks[p1, p1](x1, x2)),
                 B.dense(ks[p1, p2](x1, x2))],
                axis=1),
            np.concatenate(
                [B.dense(ks[p2, p1](x1, x2)),
                 B.dense(ks[p2, p2](x1, x2))],
                axis=1)
        ],
                       axis=0))
    allclose(
        mok.elwise(x1, x3),
        np.concatenate([ks[p1, p1].elwise(x1, x3), ks[p2, p2].elwise(x1, x3)],
                       axis=0))

    # `B.Numeric` versus `At`:
    allclose(
        mok(p1(x1), x2),
        np.concatenate(
            [B.dense(ks[p1, p1](x1, x2)),
             B.dense(ks[p1, p2](x1, x2))], axis=1))
    allclose(
        mok(p2(x1), x2),
        np.concatenate(
            [B.dense(ks[p2, p1](x1, x2)),
             B.dense(ks[p2, p2](x1, x2))], axis=1))
    allclose(
        mok(x1, p1(x2)),
        np.concatenate(
            [B.dense(ks[p1, p1](x1, x2)),
             B.dense(ks[p2, p1](x1, x2))], axis=0))
    allclose(
        mok(x1, p2(x2)),
        np.concatenate(
            [B.dense(ks[p1, p2](x1, x2)),
             B.dense(ks[p2, p2](x1, x2))], axis=0))
    with pytest.raises(ValueError):
        mok.elwise(x1, p2(x3))
    with pytest.raises(ValueError):
        mok.elwise(p1(x1), x3)

    # `At` versus `At`:
    allclose(mok(p1(x1), p1(x2)), ks[p1](x1, x2))
    allclose(mok(p1(x1), p2(x2)), ks[p1, p2](x1, x2))
    allclose(mok.elwise(p1(x1), p1(x3)), ks[p1].elwise(x1, x3))
    allclose(mok.elwise(p1(x1), p2(x3)), ks[p1, p2].elwise(x1, x3))

    # `MultiInput` versus `MultiInput`:
    allclose(
        mok(MultiInput(p2(x1), p1(x2)), MultiInput(p2(x1))),
        np.concatenate(
            [B.dense(ks[p2, p2](x1, x1)),
             B.dense(ks[p1, p2](x2, x1))], axis=0))
    with pytest.raises(ValueError):
        mok.elwise(MultiInput(p2(x1), p1(x3)), MultiInput(p2(x1)))
    allclose(
        mok.elwise(MultiInput(p2(x1), p1(x3)), MultiInput(p2(x1), p1(x3))),
        np.concatenate([ks[p2, p2].elwise(x1, x1), ks[p1, p1].elwise(x3, x3)],
                       axis=0))

    # `MultiInput` versus `At`:
    allclose(
        mok(MultiInput(p2(x1), p1(x2)), p2(x1)),
        np.concatenate(
            [B.dense(ks[p2, p2](x1, x1)),
             B.dense(ks[p1, p2](x2, x1))], axis=0))
    allclose(
        mok(p2(x1), MultiInput(p2(x1), p1(x2))),
        np.concatenate(
            [B.dense(ks[p2, p2](x1, x1)),
             B.dense(ks[p2, p1](x1, x2))], axis=1))
    with pytest.raises(ValueError):
        mok.elwise(MultiInput(p2(x1), p1(x3)), p2(x1))
    with pytest.raises(ValueError):
        mok.elwise(p2(x1), MultiInput(p2(x1), p1(x3)))
Ejemplo n.º 7
0
def test_construction(x):
    m = TensorProductMean(lambda y: y ** 2)
    m(x)

    # Test `MultiInput` construction.
    approx(m(MultiInput(x, x)), B.concat(m(x), m(x), axis=0))