Exemplo n.º 1
0
    def test___init__(self):
        sys.stdout.write(
            'StackOfBipartiteGraphs -> Performing initialzation and property test ...'
        )
        sys.stdout.flush()

        # Check init scalar
        number_visibles1 = 2
        number_hiddens1 = 4
        number_visibles2 = 4
        number_hiddens2 = 3
        number_visibles3 = 3
        number_hiddens3 = 2

        numx.random.seed(42)
        model1 = BipartiteGraph(number_visibles=number_visibles1,
                                number_hiddens=number_hiddens1,
                                data=None,
                                initial_weights=1,
                                initial_visible_bias=1,
                                initial_hidden_bias=1,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        model2 = BipartiteGraph(number_visibles=number_visibles2,
                                number_hiddens=number_hiddens2,
                                data=None,
                                initial_weights=2,
                                initial_visible_bias=2,
                                initial_hidden_bias=2,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        model3 = BipartiteGraph(number_visibles=number_visibles3,
                                number_hiddens=number_hiddens3,
                                data=None,
                                initial_weights=3,
                                initial_visible_bias=3,
                                initial_hidden_bias=3,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        stack = StackOfBipartiteGraphs([model1, model2, model3])

        assert numx.all(stack.input_dim == number_visibles1)
        assert numx.all(stack.output_dim == number_hiddens3)
        assert numx.all(stack.num_layers == 3)
        assert numx.all(stack.depth == 4)
        assert numx.all(stack[1].dtype == numx.float64)

        print(' successfully passed!')
        sys.stdout.flush()
Exemplo n.º 2
0
    def test_forward_backward_reconstruct(self):
        sys.stdout.write(
            'StackOfBipartiteGraphs -> Performing forward, backward, and reconstruct test ...'
        )
        sys.stdout.flush()

        # Check init scalar
        number_visibles1 = 2
        number_hiddens1 = 4
        number_visibles2 = 4
        number_hiddens2 = 3
        number_visibles3 = 3
        number_hiddens3 = 2

        numx.random.seed(42)
        model1 = BipartiteGraph(number_visibles=number_visibles1,
                                number_hiddens=number_hiddens1,
                                data=None,
                                initial_weights=1,
                                initial_visible_bias=1,
                                initial_hidden_bias=1,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        model2 = BipartiteGraph(number_visibles=number_visibles2,
                                number_hiddens=number_hiddens2,
                                data=None,
                                initial_weights=2,
                                initial_visible_bias=2,
                                initial_hidden_bias=2,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        model3 = BipartiteGraph(number_visibles=number_visibles3,
                                number_hiddens=number_hiddens3,
                                data=None,
                                initial_weights=3,
                                initial_visible_bias=3,
                                initial_hidden_bias=3,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        stack = StackOfBipartiteGraphs([model1, model2, model3])

        forward_target = numx.array([[0.97356463, 0.64265444],
                                     [0.974248, 0.64951497]])
        backward_target = numx.array([[0.89076868, 0.78815199],
                                      [0.93154994, 0.82386556]])
        rec_target = numx.array([[0.85960142, 0.74341554],
                                 [0.86000094, 0.74392953]])

        assert numx.sum(
            numx.abs(
                stack.forward_propagate(numx.array([[1, 2], [3, 4]])) -
                forward_target) < 0.000001)
        assert numx.sum(
            numx.abs(
                stack.backward_propagate(numx.array([[1, 2], [3, 4]])) -
                backward_target) < 0.000001)
        assert numx.sum(
            numx.abs(
                stack.backward_propagate(
                    stack.forward_propagate(numx.array([[1, 2], [3, 4]]))) -
                rec_target) < 0.000001)
        assert numx.sum(
            numx.abs(
                stack.reconstruct(numx.array([[1, 2], [3, 4]])) -
                rec_target) < 0.000001)

        print(' successfully passed!')
        sys.stdout.flush()
Exemplo n.º 3
0
    def test_append_pop(self):
        sys.stdout.write(
            'StackOfBipartiteGraphs -> Performing pop and append test ...')
        sys.stdout.flush()

        # Check init scalar
        number_visibles1 = 2
        number_hiddens1 = 4
        number_visibles2 = 4
        number_hiddens2 = 3
        number_visibles3 = 3
        number_hiddens3 = 2

        numx.random.seed(42)
        model1 = BipartiteGraph(number_visibles=number_visibles1,
                                number_hiddens=number_hiddens1,
                                data=None,
                                initial_weights=1,
                                initial_visible_bias=1,
                                initial_hidden_bias=1,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        model2 = BipartiteGraph(number_visibles=number_visibles2,
                                number_hiddens=number_hiddens2,
                                data=None,
                                initial_weights=2,
                                initial_visible_bias=2,
                                initial_hidden_bias=2,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        model3 = BipartiteGraph(number_visibles=number_visibles3,
                                number_hiddens=number_hiddens3,
                                data=None,
                                initial_weights=3,
                                initial_visible_bias=3,
                                initial_hidden_bias=3,
                                initial_visible_offsets=0,
                                initial_hidden_offsets=0,
                                dtype=numx.float64)

        stack = StackOfBipartiteGraphs([model1, model2])
        assert numx.all(stack.input_dim == number_visibles1)
        assert numx.all(stack.output_dim == number_hiddens2)
        assert numx.all(stack.num_layers == 2)
        assert numx.all(stack.depth == 3)

        stack.append_layer(model3)
        assert numx.all(stack.input_dim == number_visibles1)
        assert numx.all(stack.output_dim == number_hiddens3)
        assert numx.all(stack.num_layers == 3)
        assert numx.all(stack.depth == 4)
        assert numx.all(stack[1].dtype == numx.float64)

        model2_new = BipartiteGraph(number_visibles=number_visibles2,
                                    number_hiddens=number_hiddens2,
                                    data=None,
                                    initial_weights=2,
                                    initial_visible_bias=2,
                                    initial_hidden_bias=2,
                                    initial_visible_offsets=0,
                                    initial_hidden_offsets=0,
                                    dtype=numx.int32)
        stack[1] = model2_new
        assert numx.all(stack[1].dtype == numx.int32)

        stack.pop_last_layer()
        assert numx.all(stack.input_dim == number_visibles1)
        assert numx.all(stack.output_dim == number_hiddens2)
        assert numx.all(stack.num_layers == 2)
        assert numx.all(stack.depth == 3)

        stack.append_layer(model3)
        assert numx.all(stack.depth == 4)
        assert numx.all(stack.output_dim == number_hiddens3)

        stack.pop_last_layer()
        assert numx.all(stack.input_dim == number_visibles1)
        assert numx.all(stack.output_dim == number_hiddens2)
        assert numx.all(stack.num_layers == 2)
        assert numx.all(stack.depth == 3)

        stack.pop_last_layer()
        assert numx.all(stack.input_dim == number_visibles1)
        assert numx.all(stack.output_dim == number_hiddens1)
        assert numx.all(stack.num_layers == 1)
        assert numx.all(stack.depth == 2)

        stack.pop_last_layer()
        assert numx.all(stack.input_dim == None)
        assert numx.all(stack.output_dim == None)
        assert numx.all(stack.num_layers == 0)
        assert numx.all(stack.depth == 1)

        stack.pop_last_layer()
        assert numx.all(stack.input_dim == None)
        assert numx.all(stack.output_dim == None)
        assert numx.all(stack.num_layers == 0)
        assert numx.all(stack.depth == 1)

        print(' successfully passed!')
        sys.stdout.flush()