Non-lazy execution of ifelse

bug_softmax_crossentropy.py

"""
Code by @mducoffe
Tested with:
- Blocks commit dea5cf31bedacb16c16d8fcc04a8c8205c6d9396
- Fuel commit a00fee301220a6ed80ed34a72b2d265bd0dc49f9
"""
import numpy as np
import theano
import theano.tensor as T
from blocks.bricks import Rectifier, Softmax, MLP, Identity
from blocks.bricks.conv import ConvolutionalLayer, ConvolutionalSequence, Flattener
from blocks.initialization import Constant, Uniform, IsotropicGaussian
from blocks.algorithms import GradientDescent
from blocks.graph import ComputationGraph
from blocks.extensions import FinishAfter, Printing
from blocks.extensions.monitoring import DataStreamMonitoring
from blocks.model import Model
from fuel.streams import DataStream
from fuel.schemes import SequentialScheme
from blocks.main_loop import MainLoop
from blocks.algorithms import Scale
from fuel.datasets import MNIST
floatX = theano.config.floatX


def test_bug_blocks_on_mnist():

    x = T.tensor4('features')
    y = T.imatrix('targets')
    batch_size = 32
    num_channels = 1
    filter_size = (3,3)
    pooling_size = 2
    activation = Rectifier().apply

    num_filters = 50
    layer0 = ConvolutionalLayer(activation=activation,
                                filter_size = filter_size,
                                num_filters = num_filters,
                                pooling_size=(pooling_size, pooling_size),
                                name="layer0")

    layer1 = ConvolutionalLayer(activation=activation,
                                filter_size = filter_size,
                                num_filters = num_filters,
                                pooling_size=(pooling_size, pooling_size),
                                name="layer1")

    conv_layers = [layer0, layer1]
    convnet = ConvolutionalSequence(conv_layers, num_channels= 1,
                                    image_size=(28, 28),
                                    weights_init=IsotropicGaussian(0.1),
                                    biases_init=Uniform(width=0.1),
                                    name="convnet")
    convnet.initialize()
    output_dim = np.prod(convnet.get_dim('output'))

    mlp = MLP(activations=[Rectifier(), Identity()],
             dims =[output_dim, 100, 10],
             weights_init=IsotropicGaussian(0.1),
             biases_init=Uniform(width=0.1),
             name="mlp")

    mlp.initialize()

    output_conv = Flattener().apply(convnet.apply(x))
    output_mlp = mlp.apply(output_conv)

    mlp.initialize()

    output_conv = Flattener().apply(convnet.apply(x))
    output_mlp = mlp.apply(output_conv)

    # BUG
    diagnostic_bug = output_mlp
    diagnostic_bug.name = "diagnostic_bug"
    cost = Softmax().categorical_cross_entropy(y.flatten(), output_mlp)
    cost.name = "cost"
    cg = ComputationGraph(cost)
    step_rule = Scale(learning_rate=0.1)
    # training on mnist

    train_set = MNIST('train')

    data_stream = DataStream.default_stream(
            train_set, iteration_scheme=SequentialScheme(train_set.num_examples, batch_size))


    algorithm = GradientDescent(cost=cost, params=cg.parameters,
                                step_rule=step_rule)


    test_set = MNIST("test")

    data_stream_test =DataStream.default_stream(
            test_set, iteration_scheme=SequentialScheme(test_set.num_examples, batch_size))

    monitor_valid = DataStreamMonitoring(
        variables=[cost, diagnostic_bug], data_stream=data_stream_test, prefix="test", every_n_batches=10)


    extensions = [  monitor_valid,
                    FinishAfter(after_n_epochs=2),
                    Printing(every_n_batches=10)
                  ]

    main_loop = MainLoop(data_stream=data_stream,
                        algorithm=algorithm, model = Model(cost),
                        extensions=extensions)
    main_loop.run()


if __name__ == '__main__':
     test_bug_blocks_on_mnist()