Compile

docs/user/tutorial.rst

@@ -28,18 +28,12 @@ We will first import yadll and configure a basic logger.
     logging.basicConfig(level=logging.DEBUG, format='%(message)s')
 
 Then we load the MNIST dataset (or download it) and create a
-:class:`yadll.data.Data` instance that will hold the data
+:class:`yadll.data.Data` instance that will hold the data. We call a loader function to retrieve the data and fill the container.
 
 .. code-block:: python
 
     # load the data
-    datafile = 'mnist.pkl.gz'
-    if not os.path.isfile(datafile):
-        import urllib
-        origin = 'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
-        print 'Downloading data from %s' % origin
-        urllib.urlretrieve(origin, datafile)
-    data = yadll.data.Data(datafile)
+    data = yadll.data.Data(yadll.data.mnist_loader())
 
 We now create a :class:`yadll.model.Model`, that is the class that contain
 the data, the network, the hyperparameters and the updates function. As a file

examples/networks.py

@@ -17,8 +17,6 @@
            'rbm',
            'dbn',
            'batch_normalization',
-           'rnn',
-           'lstm'
            ]
 
 
@@ -164,13 +162,13 @@ def convpool(input_var=None):
     # Create connected layers
     image_shape = (None, 1, 28, 28)    # (batch size, nb input feature maps, image height, image width)
     filter_shape = (20, 1, 5, 5)       # (number of filters, nb input feature maps, filter height, filter width)
-    poolsize = (2, 2)                  # downsampling factor per (row, col)
+    pool_size = (2, 2)                  # downsampling factor per (row, col)
     # Input layer
     l_in = InputLayer(input_shape=(None, 28 * 28), input_var=input_var, name='Input')
     # ConvLayer needs 4D Tensor
     l_rs = ReshapeLayer(incoming=l_in, output_shape=image_shape)
     # ConvPool Layer
-    l_cp = ConvPoolLayer(incoming=l_rs, poolsize=poolsize, image_shape=image_shape,
+    l_cp = ConvPoolLayer(incoming=l_rs, pool_size=pool_size, image_shape=image_shape,
                          filter_shape=filter_shape, name='ConvPool layer')
     # flatten convpool output
     l_fl = FlattenLayer(incoming=l_cp, ndim=2)
@@ -205,14 +203,14 @@ def lenet5(input_var=None):
     l_rs = ReshapeLayer(incoming=l_in, output_shape=image_shape)
     # first convpool
     filter_shape = (20, 1, 5, 5)
-    poolsize = (2, 2)
-    l_cp1 = ConvPoolLayer(incoming=l_rs, poolsize=poolsize, image_shape=image_shape,
+    pool_size = (2, 2)
+    l_cp1 = ConvPoolLayer(incoming=l_rs, pool_size=pool_size, image_shape=image_shape,
                           filter_shape=filter_shape, name='ConvPool layer 1')
     # second convpool
     image_shape = (None, 20, 12, 12)   # (batch size, nb filters, (28-5)/2, (28-5)/2)
     filter_shape = (50, 20, 5, 5)
-    poolsize = (2, 2)
-    l_cp2 = ConvPoolLayer(incoming=l_cp1, poolsize=poolsize, image_shape=image_shape,
+    pool_size = (2, 2)
+    l_cp2 = ConvPoolLayer(incoming=l_cp1, pool_size=pool_size, image_shape=image_shape,
                           filter_shape=filter_shape, name='ConvPool layer 2')
     # flatten convpool output
     l_fl = FlattenLayer(incoming=l_cp2, ndim=2)
@@ -482,7 +480,7 @@ def batch_normalization(input_var=None):
 
     # Hyperparameters
     hp = Hyperparameters()
-    hp('batch_size', 32)
+    hp('batch_size', 30)
     hp('n_epochs', 1000)
     hp('learning_rate', 0.01)
     hp('l1_reg', 0.00)
@@ -519,51 +517,3 @@ def batch_normalization(input_var=None):
     net.add(l_out)
 
     return net, hp
-
-
-def rnn(input_var=None):
-    """Recurrent Neural Network"""
-
-    # Hyperparameters
-    hp = Hyperparameters()
-    hp('batch_size', 500)
-    hp('n_epochs', 1000)
-    hp('learning_rate', 0.1)
-    hp('patience', 500)
-
-    # Create connected layers
-    l_in = InputLayer(input_shape=(None, 28 * 28), input_var=input_var, name='Input')
-    l_rnn = RNN(incoming=l_in, n_units=100, name='Recurrent Neural Network')
-    l_out = LogisticRegression(incoming=l_rnn, n_class=10, name='Logistic regression')
-
-    # Create network and add layers
-    net = Network('rnn')
-    net.add(l_in)
-    net.add(l_rnn)
-    net.add(l_out)
-
-    return net, hp
-
-
-def lstm(input_var=None):
-    """Long Short Term Memory"""
-
-    # Hyperparameters
-    hp = Hyperparameters()
-    hp('batch_size', 500)
-    hp('n_epochs', 1000)
-    hp('learning_rate', 0.1)
-    hp('patience', 500)
-
-    # Create connected layers
-    l_in = InputLayer(input_shape=(None, 28 * 28), input_var=input_var, name='Input')
-    l_lstm = LSTM(incoming=l_in, n_units=100, name='Long Short Term Memory')
-    l_out = LogisticRegression(incoming=l_lstm, n_class=10, name='Logistic regression')
-
-    # Create network and add layers
-    net = Network('lstm')
-    net.add(l_in)
-    net.add(l_lstm)
-    net.add(l_out)
-
-    return net, hp

yadll/layers.py

@@ -360,29 +360,29 @@ class PoolLayer(Layer):
     """
     n_instances = 0
 
-    def __init__(self, incoming, poolsize, stride=None, ignore_border=True,
-                 padding=(0, 0), mode='max', **kwargs):
+    def __init__(self, incoming, pool_size, stride=None, ignore_border=True,
+                 pad=(0, 0), mode='max', **kwargs):
         super(PoolLayer, self).__init__(incoming, **kwargs)
-        self.poolsize = poolsize
+        self.pool_size = pool_size
         self.stride = stride    # If st is None, it is considered equal to ds
         self.ignore_border = ignore_border
-        self.padding = padding
+        self.pad = pad
         self.mode = mode    # {'max', 'sum', 'average_inc_pad', 'average_exc_pad'}
 
-    def pool(self, input, ds):
-        return pool.pool_2d(input=input, ds=ds, st=self.stride, ignore_border=self.ignore_border,
-                                      padding=self.padding, mode=self.mode)
+    def pool(self, input, ws):
+        return pool.pool_2d(input=input, ws=ws, st=self.stride, ignore_border=self.ignore_border,
+                            pad=self.pad, mode=self.mode)
 
     @property
     def output_shape(self):
         return (self.input_shape[0],
                 self.input_shape[1],
-                self.input_shape[2] / self.poolsize[0],
-                self.input_shape[3] / self.poolsize[1])
+                self.input_shape[2] / self.pool_size[0],
+                self.input_shape[3] / self.pool_size[1])
 
     def get_output(self, stochastic=False, **kwargs):
         X = self.input_layer.get_output(stochastic=stochastic, **kwargs)
-        return self.pool(input=X, ds=self.poolsize)
+        return self.pool(input=X, ws=self.pool_size)
 
 
 class ConvLayer(Layer):
@@ -437,10 +437,10 @@ class ConvPoolLayer(ConvLayer, PoolLayer):
     """
     n_instances = 0
 
-    def __init__(self, incoming, poolsize, image_shape=None, filter_shape=None,
-                  b=constant, activation=tanh, **kwargs):
-        super(ConvPoolLayer, self).__init__(incoming, poolsize=poolsize, image_shape=image_shape,
-                                            filter_shape=filter_shape, pool_scale=poolsize, **kwargs)
+    def __init__(self, incoming, pool_size, image_shape=None, filter_shape=None,
+                 b=constant, activation=tanh, **kwargs):
+        super(ConvPoolLayer, self).__init__(incoming, pool_size=pool_size, image_shape=image_shape,
+                                            filter_shape=filter_shape, pool_scale=pool_size, **kwargs)
         self.b = initializer(b, shape=(self.filter_shape[0],), name='b')
         self.params.append(self.b)
         self.activation = get_activation(activation)
@@ -449,14 +449,14 @@ def __init__(self, incoming, poolsize, image_shape=None, filter_shape=None,
     def output_shape(self):
         return (self.input_shape[0],
                 self.filter_shape[0],
-                (self.image_shape[2] - self.filter_shape[2] + 1) / self.poolsize[0],
-                (self.image_shape[3] - self.filter_shape[3] + 1) / self.poolsize[1])
+                (self.image_shape[2] - self.filter_shape[2] + 1) / self.pool_size[0],
+                (self.image_shape[3] - self.filter_shape[3] + 1) / self.pool_size[1])
 
     def get_output(self, stochastic=False, **kwargs):
         X = self.input_layer.get_output(stochastic=stochastic, **kwargs)
         conv_X = self.conv(input=X, filters=self.W, image_shape=self.image_shape,
                            filter_shape=self.filter_shape)
-        pool_X = self.pool(input=conv_X, ds=self.poolsize)
+        pool_X = self.pool(input=conv_X, ws=self.pool_size)
         return self.activation(pool_X + self.b.dimshuffle('x', 0, 'x', 'x'))
 
 

yadll/model.py

@@ -218,8 +218,10 @@ def train(self, unsupervised_training=True, save_mode=None, early_stop=True, shu
             report
         """
         start_time = timeit.default_timer()
+
         if self.data is None:
             raise NoDataFoundException
+
         if self.network is None:
             raise NoNetworkFoundException
 
@@ -228,6 +230,14 @@ def train(self, unsupervised_training=True, save_mode=None, early_stop=True, shu
 
         self.early_stop = early_stop and self.has_validation
 
+        ################################################
+        # Compile if not done already
+        if self.train_func is None:
+            compile_arg = kwargs.pop('compile_arg', ['train', 'test'])
+            if self.has_validation:
+                compile_arg.append('validate')
+            self.compile(compile_arg=compile_arg)
+
         if unsupervised_training and self.network.has_unsupervised_layer:
             self.pretrain()
 
@@ -253,14 +263,6 @@ def train(self, unsupervised_training=True, save_mode=None, early_stop=True, shu
         self.report['test_values'] = []
         self.report['validation_values'] = []
 
-        ################################################
-        # Compile if not done already
-        if self.train_func is None:
-            compile_arg = kwargs.pop('compile_arg', ['train', 'test'])
-            if self.has_validation:
-                compile_arg.append('validate')
-            self.compile(compile_arg=compile_arg)
-
         ################################################
         # Training
         logger.info('... Training the model')