コード例 #1
0
ファイル: test.py プロジェクト: tpq/tf-logic
    def test_transposition(self):
        """This test is for evaluating caching when the same variable is used as two different arguments of the same predicate"""

        World.reset()

        def inside(x, y):
            centers_distance = tf.sqrt(
                tf.reduce_sum(tf.squared_difference(x[:, 0:2], y[:, 0:2]),
                              axis=1) + 1e-6)
            return tf.cast((centers_distance + x[:, 2]) < y[:, 2], tf.float32)

        circles = tfl.Domain(label="Circles",
                             data=[[0., 0, 1], [0, 0, 2], [0, 0, 3]])
        inside = tfl.Predicate(label="inside",
                               domains=["Circles", "Circles"],
                               function=inside)
        tfl.setTNorm(id=tfl.SS, p=1)
        sess = tf.Session()

        # Constraint 1
        x = tfl.variable(circles, name="x")
        y = tfl.variable(circles, name="y")
        a = tfl.atom(inside, (x, y))
        b = tfl.atom(inside, (y, x))
        rule = tfl.and_n(a, b)

        assert np.greater(sess.run(rule), np.zeros(shape=[3, 3, 3])).all()
        assert len(World._predicates_cache) == 1
コード例 #2
0
ファイル: test.py プロジェクト: tpq/tf-logic
    def test_subdomain(self):
        World.reset()
        """Checking caching mechanism works"""

        # Program Model
        nn = tfl.functions.FeedForwardNN(input_shape=[2], output_size=2)
        images = tfl.Domain(label="Images", data=[[0., 0], [1, 1], [0.2, 0.3]])
        supervised_images = tfl.Domain(label="SupImages",
                                       data=[[0., 0], [1, 1]],
                                       father=images)
        zero = tfl.Predicate(label="zero",
                             domains=["Images"],
                             function=tfl.functions.Slice(nn, 0))
        one = tfl.Predicate(label="one",
                            domains=["Images"],
                            function=tfl.functions.Slice(nn, 1))
        tfl.setTNorm(id=tfl.PRODUCT, p=None)

        # Constraint 1
        c1 = tfl.constraint("zero(x) and one(x)", {"x": supervised_images})

        x = tfl.variable(supervised_images, name="x")
        c2 = tfl.and_n(zero(x), one(x))

        sess = tf.Session()
        sess.run(tf.global_variables_initializer())
        assert len(sess.run(c1)) == supervised_images.size
        assert np.equal(sess.run(c1), sess.run(c2)).all()
コード例 #3
0
ファイル: test.py プロジェクト: tpq/tf-logic
    def test_parser_forall(self):

        World.reset()
        World._evaluation_mode = tfl.LOGIC_MODE
        tfl.setTNorm(id=tfl.SS, p=1)

        sess = tf.Session()

        def inside(x, y):
            centers_distance = tf.sqrt(
                tf.reduce_sum(tf.squared_difference(x[:, 0:2], y[:, 0:2]),
                              axis=1) + 1e-6)
            return tf.cast((centers_distance + x[:, 2]) < y[:, 2], tf.float32)

        circles = tfl.Domain(label="Circles",
                             data=[[0., 0, 1], [0, 0, 2], [0, 0, 3]])
        inside = tfl.Predicate(label="inside",
                               domains=["Circles", "Circles"],
                               function=inside)

        x = tfl.variable(circles, "x")
        y = tfl.variable(circles, "y")

        symmetric_formula = tfl.forall(
            x, tfl.forall(y, tfl.and_n(inside(x, y), inside(y, x))))
        symmetric_parsed = tfl.constraint(
            "forall x: forall y: inside(x,y) and inside(y,x)")
        assert np.equal(sess.run(symmetric_formula),
                        sess.run(symmetric_parsed))
コード例 #4
0
ファイル: test.py プロジェクト: tpq/tf-logic
    def test_parser_and(self):

        World.reset()
        World._evaluation_mode = tfl.LOGIC_MODE

        def inside(x, y):
            centers_distance = tf.sqrt(
                tf.reduce_sum(tf.squared_difference(x[:, 0:2], y[:, 0:2]),
                              axis=1) + 1e-6)
            return tf.cast((centers_distance + x[:, 2]) < y[:, 2], tf.float32)

        tfl.setTNorm(id=tfl.SS, p=1)
        circles = tfl.Domain(label="Circles",
                             data=[[0., 0, 1], [0, 0, 2], [0, 0, 3]])
        inside = tfl.Predicate(label="inside",
                               domains=["Circles", "Circles"],
                               function=inside)

        x = tfl.variable(circles, "x")
        y = tfl.variable(circles, "y")
        a = tfl.atom(inside, (x, y))
        b = tfl.atom(inside, (y, x))
        f = tfl.and_n(a, b)

        tensor = tfl.constraint("inside(x,y) and inside(y,x)")

        sess = tf.Session()

        assert np.equal(sess.run(tensor), sess.run(f)).all()
コード例 #5
0
ファイル: test.py プロジェクト: tpq/tf-logic
    def test_slice_caching(self):
        World.reset()
        """Checking caching mechanism works"""

        # Program Model
        nn = tfl.functions.FeedForwardNN(input_shape=[2], output_size=2)
        images = tfl.Domain(label="Images", data=[[0., 0], [1, 1], [0.2, 0.3]])
        zero = tfl.Predicate(label="zero",
                             domains=["Images"],
                             function=tfl.functions.Slice(nn, 0))
        one = tfl.Predicate(label="one",
                            domains=["Images"],
                            function=tfl.functions.Slice(nn, 1))
        close = tfl.Predicate(
            label="close",
            domains=["Images", "Images"],
            function=lambda x: tf.reduce_sum(tf.abs(x[0] - x[1]), axis=1))
        tfl.setTNorm(id=tfl.PRODUCT, p=None)

        # Constraint 1
        c1 = tfl.constraint("forall x: zero(x) and one(x) and one(y)")
コード例 #6
0
ファイル: test.py プロジェクト: tpq/tf-logic
    def test_cache(self):

        World.reset()

        a = tf.zeros([10, 10])

        print(a)
        """Checking caching mechanism works"""

        # Program Model
        nn1 = lambda x: tf.constant([0., 1, 0])
        nn2 = lambda x: tf.constant([0., 0, 0])
        images = tfl.Domain(label="Images", data=[[0., 0], [1, 1], [0.2, 0.3]])
        zero = tfl.Predicate(label="zero", domains=["Images"], function=nn1)
        one = tfl.Predicate(label="one", domains=["Images"], function=nn2)
        close = tfl.Predicate(
            label="close",
            domains=["Images", "Images"],
            function=lambda x, y: tf.reduce_sum(tf.abs(x - y), axis=1))
        tfl.setTNorm(id=tfl.PRODUCT, p=None)

        # Constraint 1
        "zero(x) and one(y)"
        x = tfl.variable(images)
        y = tfl.variable(images)
        a = tfl.atom(zero, (x, ))
        b = tfl.atom(one, (y, ))
        andd = tfl.and_n(a, b)

        # Constraint 2
        z = tfl.variable(images)
        h = tfl.variable(images)
        c = tfl.atom(zero, (z, ))
        d = tfl.atom(one, (h, ))
        papapa = tfl.and_n(c, d)
        ab = tfl.atom(close, (x, y))

        assert len(World._predicates_cache
                   ) == 3  # one of zero, one for one and one for close