--- a/pylearn/algorithms/daa.py	Wed Jan 21 03:20:16 2009 -0500
+++ b/pylearn/algorithms/daa.py	Wed Jan 21 03:23:50 2009 -0500
@@ -1,186 +1,469 @@
-
 import theano
 from theano import tensor as T
 from theano.tensor import nnet as NN
+from hpu.conv import sp
 import numpy as N
+from theano.printing import Print
 
-from pylearn import cost as cost
-
-class DenoisingAA(T.RModule):
-    """De-noising Auto-encoder
+from pylearn.algorithms import cost
 
-    WRITEME
+# TODO: make this more generic (somewhere in pylearn)
+def lnorm(param, type='L2'):
+    if type == 'L1':
+        return T.sum(T.abs(param))
+    if type == 'L2':
+        return T.sum(param*param)
+    raise NotImplementedError('Only L1 and L2 regularization are currently implemented')
 
-    Abstract base class. Requires subclass with functions:
-    
-    - build_corrupted_input()
+def get_reg_cost(params, type):
+    rcost = 0
+    for param in params:
+        rcost += lnorm(param, type)
+    return rcost
 
-    Introductory article about this model WRITEME.
+class ScratchPad:
+    pass
 
-
+class DAA(T.RModule):
+    """De-noising Auto-encoder
     """
 
-    def __init__(self, input = None, regularize = True, tie_weights = True,
-            activation_function=NN.sigmoid, reconstruction_cost_function=cost.cross_entropy):
+    # TODO: change n_hid_per_pixel to nkern
+    def __init__(self, img_shape, n_hid_per_pixel,
+                 batch_size=4, regularize = True, tie_weights = False,
+                 hid_fn=NN.sigmoid, reconstruction_cost_function=cost.cross_entropy, **init):
         """
-        :param input: WRITEME
-
         :param regularize: WRITEME
-
         :param tie_weights: WRITEME
-
-        :param activation_function: WRITEME
-
+        :param hid_fn: WRITEME
         :param reconstruction_cost: Should return one cost per example (row)
-
         :todo: Default noise level for all daa levels
 
         """
-        super(DenoisingAA, self).__init__()
+        super(DAA, self).__init__()
 
         # MODEL CONFIGURATION
+        self.img_shape = img_shape
+        self.input_size = N.prod(img_shape)
+        self.n_hid_per_pixel = n_hid_per_pixel
+        self.batch_size = batch_size
         self.regularize = regularize
         self.tie_weights = tie_weights
-        self.activation_function = activation_function
+        self.hid_fn = hid_fn
         self.reconstruction_cost_function = reconstruction_cost_function
 
-        # ACQUIRE/MAKE INPUT
-        if not input:
-            input = T.matrix('input')
-        self.input = theano.External(input)
-
-        # HYPER-PARAMETERS
+        ### DECLARE MODEL VARIABLES
+        self.input = theano.External(T.dmatrix('input'))
+        
+        #parameters
+        self.w1 = theano.Member(T.dmatrix())
+        self.w2 = self.w1.T if tie_weights else theano.Member(T.dmatrix())
+        self.b1 = theano.Member(T.dvector())
+        self.b2 = theano.Member(T.dvector())
+       
+        #hyper-parameters
         self.lr = theano.Member(T.scalar())
 
-        # PARAMETERS
-        self.w1 = theano.Member(T.matrix())
-        if not tie_weights:
-            self.w2 = theano.Member(T.matrix())
-        else:
-            self.w2 = self.w1.T
-        self.b1 = theano.Member(T.vector())
-        self.b2 = theano.Member(T.vector())
 
-
-        # REGULARIZATION COST
-        self.regularization = self.build_regularization()
+    ### BEHAVIOURAL MODEL
+    def init_behavioural(self):
+        self.noisy_input = self.corrupt_input()
+        self.noise = ScratchPad()
+        self.clean = ScratchPad()
+        self.define_behavioural(self.clean, self.input)
+        self.define_behavioural(self.noise, self.noisy_input)
+        self.define_regularization()  # call before cost
+        self.define_cost(self.clean)
+        self.define_cost(self.noise)
+        self.define_gradients()
+        self.define_interface()
 
 
-        ### NOISELESS ###
-
-        # HIDDEN LAYER
-        self.hidden_activation = T.dot(self.input, self.w1) + self.b1
-        self.hidden = self.hid_activation_function(self.hidden_activation)
+    def define_behavioural(self,container, input):
+        self.define_propup(container, input)
+        self.define_propdown(container)
 
-        # RECONSTRUCTION LAYER
-        self.output_activation = T.dot(self.hidden, self.w2) + self.b2
-        self.output = self.out_activation_function(self.output_activation)
+    def define_propup(self, container, input):
+        container.hidden_activation = T.dot(input, self.w1) + self.b1
+        container.hidden = self.hid_fn(container.hidden_activation)
 
-        # RECONSTRUCTION COST
-        self.reconstruction_costs = self.build_reconstruction_costs(self.output)
-        self.reconstruction_cost = T.mean(self.reconstruction_costs)
-
-        # TOTAL COST
-        self.cost = self.reconstruction_cost
-        if self.regularize:
-            self.cost = self.cost + self.regularization
+    # DEPENDENCY: define_propup
+    def define_propdown(self, container):
+        container.output_activation = T.dot(container.hidden, self.w2) + self.b2
+        container.output = self.hid_fn(container.output_activation)
 
 
-        ### WITH NOISE ###
-        self.corrupted_input = self.build_corrupted_input()
-
-        # HIDDEN LAYER
-        self.nhidden_activation = T.dot(self.corrupted_input, self.w1) + self.b1
-        self.nhidden = self.hid_activation_function(self.nhidden_activation)
+    # TODO: fix regularization type (outside parameter ?)
+    def define_regularization(self, regtype=None):
+        if regtype == None:
+            self.regularization = T.zero() # base model has no regularization!
+            return
+        self.reg_coef = theano.Member(T.scalar())
+        self.regularization = self.reg_coef * get_reg_cost([self.w1,self.w2], 'L2')
 
-        # RECONSTRUCTION LAYER
-        self.noutput_activation = T.dot(self.nhidden, self.w2) + self.b2
-        self.noutput = self.out_activation_function(self.noutput_activation)
 
-        # RECONSTRUCTION COST
-        self.nreconstruction_costs = self.build_reconstruction_costs(self.noutput)
-        self.nreconstruction_cost = T.mean(self.nreconstruction_costs)
-
+    # DEPENDENCY: define_behavioural, define_regularization
+    def define_cost(self, container):
+        container.reconstruction_cost = self.reconstruction_costs(container.output)
         # TOTAL COST
-        self.ncost = self.nreconstruction_cost
+        container.cost = container.reconstruction_cost
         if self.regularize:
-            self.ncost = self.ncost + self.regularization
+            container.cost = container.cost + self.regularization
 
 
-        # GRADIENTS AND UPDATES
+    # DEPENDENCY: define_cost
+    def define_gradients(self):
+        if not hasattr(self,'params'):
+            self.params = []
         if self.tie_weights:
-            self.params = self.w1, self.b1, self.b2
+            self.params += [self.w1, self.b1, self.b2]
         else:
-            self.params = self.w1, self.w2, self.b1, self.b2
-        gradients = T.grad(self.ncost, self.params)
-        updates = dict((p, p - self.lr * g) for p, g in zip(self.params, gradients))
+            self.params += [self.w1, self.w2, self.b1, self.b2]
 
-        # INTERFACE METHODS
-        self.update = theano.Method(self.input, self.ncost, updates)
-        self.compute_cost = theano.Method(self.input, self.cost)
-        self.noisify = theano.Method(self.input, self.corrupted_input)
-        self.reconstruction = theano.Method(self.input, self.output)
-        self.representation = theano.Method(self.input, self.hidden)
-        self.reconstruction_through_noise = theano.Method(self.input, [self.corrupted_input, self.noutput])
+        self.gradients = T.grad(self.noise.cost, self.params)
+        self.updates = dict((p, p - self.lr * g) for p, g in \
+                zip(self.params, self.gradients))
 
-        self.validate = theano.Method(self.input, [self.cost, self.output])
 
-    def _instance_initialize(self, obj, input_size = None, hidden_size = None, seed = None, **init):
-        if (input_size is None) ^ (hidden_size is None):
-            raise ValueError("Must specify input_size and hidden_size or neither.")
-        super(DenoisingAA, self)._instance_initialize(obj, **init)
-        if seed is not None:
-            R = N.random.RandomState(seed)
-        else:
-            R = N.random
-        if input_size is not None:
-            sz = (input_size, hidden_size)
-            inf = 1/N.sqrt(input_size)
-            hif = 1/N.sqrt(hidden_size)
-            obj.w1 = R.uniform(size = sz, low = -inf, high = inf)
-            if not self.tie_weights:
-                obj.w2 = R.uniform(size = list(reversed(sz)), low = -hif, high = hif)
-            obj.b1 = N.zeros(hidden_size)
-            obj.b2 = N.zeros(input_size)
+    # DEPENDENCY: define_behavioural, define_regularization, define_cost, define_gradients
+    def define_interface(self):
+        self.update = theano.Method(self.input, self.noise.cost, self.updates)
+        self.compute_cost = theano.Method(self.input, self.clean.cost)
+        self.noisify = theano.Method(self.input, self.noisy_input)
+        self.reconstruction = theano.Method(self.input, self.clean.output)
+        self.representation = theano.Method(self.input, self.clean.hidden)
+        self.reconstruction_through_noise = theano.Method(self.input,\
+                [self.noisy_input, self.noise.output])
+        self.validate = theano.Method(self.input, [self.clean.cost, self.clean.output])
+    
+
+    def corrupt_input(self):
+        self.noise_level = theano.Member(T.scalar())
+        return self.random.binomial(T.shape(self.input), 1, 1 - self.noise_level) * self.input
+
+    # what about filter_scale ?
+    def _instance_initialize(self, obj, lr=None, seed=1, alloc=True, **init):
+       
+        init.setdefault('reg_coef', 0)
+        init.setdefault('noise_level', 0)
+        obj.lr = lr
+
+        super(DAA, self)._instance_initialize(obj, **init)
+        
+        self.R = N.random.RandomState(seed) if seed is not None else N.random
         if seed is not None:
             obj.seed(seed)
         obj.__hide__ = ['params']
 
-    def build_regularization(self):
-        """
-        @todo: Why do we need this function?
-        """
-        return T.zero() # no regularization!
+        self.inf = 1/N.sqrt(self.input_size)
+        self.hif = 1/N.sqrt(self.n_hid_per_pixel)
+
+        if alloc:
+            w1shp = (self.input_size, self.n_hid_per_pixel)
+            w2shp = list(reversed(w1shp))
+            
+            obj.w1 = self.R.uniform(size=w1shp, low = -self.inf, high = self.inf)
+            if not self.tie_weights:
+                obj.w2 = self.R.uniform(size=w2shp, low=-self.hif, high=self.hif)
+           
+            obj.b1 = N.zeros(self.n_hid_per_pixel)
+            obj.b2 = N.zeros(self.input_size)
+
+
+
+    #TODO: these should be made generic
+    ############## HELPER FUNCTIONS #####################
+    def reconstruction_costs(self, output):
+        return self.reconstruction_cost_function(self.input, output)
+
+
+##############################################
+#              QUADRATIC DAA                 #
+##############################################
+class QuadraticDAA(DAA):
+
+    def __init__(self, img_shape, n_hid_per_pixel, n_quadratic_filters=0,
+                 batch_size=4, regularize = True, hid_fn=NN.sigmoid,
+                 reconstruction_cost_function=cost.cross_entropy, **init):
+
+        # set tied-weights to False for QDAAs
+        super(QuadraticDAA, self).__init__(img_shape, n_hid_per_pixel, batch_size, regularize,
+                False, hid_fn, reconstruction_cost_function, **init)
+
+        self.n_quadratic_filters = n_quadratic_filters
+        self.qfilters = [theano.Member(T.dmatrix()) \
+                for i in xrange(n_quadratic_filters)]
+
+    # TODO: verify with James that the formula is correct (without sqrt)
+    def define_propup(self, container, input):
+        if self.n_quadratic_filters:
+            qsum = 0
+            for qf in self.qfilters:
+                qsum = qsum + T.dot(input, qf)**2
+            container.hidden_activation = T.dot(input, self.w1) + self.b1 + qsum
+        else:
+            container.hidden_activation = T.dot(input, self.w1) + self.b1
+        container.hidden = self.hid_fn(container.hidden_activation)
+
+    def define_gradients(self):
+        self.params = self.qfilters
+        DAA.define_gradients(self)
+
+    def _instance_initialize(self, obj, lr, seed=1, qfilter_relscale=.01, **init):
+        # only call constructor of base-class if we are instantiating QuadraticDAA
+        if self.__class__ == QuadraticDAA:
+            super(QuadraticDAA, self)._instance_initialize(obj, lr, seed, **init)
+        obj.qfilters = [self.R.uniform(size=obj.w1.shape, low=-self.inf, high=self.inf)*\
+                qfilter_relscale for qf in self.qfilters]
+
+
+
+##############################################
+#        SPARSE QUADRATIC DAA                #
+##############################################
+class SparseQuadraticDAA(QuadraticDAA):
+
+    def __init__(self, img_shape, n_hid_per_pixel,
+                 filter_shape, step_size=(1,1), conv_mode='valid',
+                 n_quadratic_filters=0, batch_size=4,
+                 regularize = True, hid_fn=NN.sigmoid,
+                 reconstruction_cost_function=cost.cross_entropy, **init):
+
+        QuadraticDAA.__init__(self, img_shape, n_hid_per_pixel, n_quadratic_filters,
+                batch_size, regularize, hid_fn, reconstruction_cost_function, **init)
+       
+        # need to override parameters for sparse operations (vector instead of matrix)
+        self.w1 = theano.Member(T.dvector())
+        self.w2 = theano.Member(T.dmatrix())
+        self.qfilters = [theano.Member(T.dvector()) for i in xrange(n_quadratic_filters)]
+
+        self.filter_shape = filter_shape
+        self.step_size = step_size
+        self.conv_mode = conv_mode
+
+    def define_propup(self, container, input):
+
+        lin_hid_activ, self.hid_shape = sp.applySparseFilter(\
+                self.w1, self.filter_shape, self.n_hid_per_pixel,
+                self.input, self.img_shape, self.step_size, self.conv_mode)
+        self.nl1feats = N.prod(self.hid_shape)
+
+        # apply quadratic filters
+        qsum = 0
+        for qf in self.qfilters:
+            temp, hidshape = sp.applySparseFilter(qf, self.filter_shape,\
+                    self.n_hid_per_pixel, self.input, self.img_shape,
+                    self.step_size, self.conv_mode)
+            qsum = qsum + temp**2
+        quad_hid_activ = qsum
+
+        hid_activ = lin_hid_activ + quad_hid_activ if self.n_quadratic_filters \
+                    else lin_hid_activ
+
+        container.hidden_activation = hid_activ
+        container.hidden = self.hid_fn(container.hidden_activation)
+
+    def define_propdown(self, container):
+        pass
+
+    def _instance_initialize(self, obj, lr, seed=1, qfilter_relscale=.01, **init):
+
+        # change weight shapes based on sparse weight matrix parameters
+        DAA._instance_initialize(self, obj, lr, seed, alloc=False, **init)
+
+        # override weight initialization
+        w1shp = N.prod(self.hid_shape)*N.prod(self.filter_shape)
+        w2shp = (N.prod(self.hid_shape), self.input_size)
+        obj.w1 = self.R.uniform(size=w1shp, low=-self.inf, high=self.inf)
+        obj.w2 = self.R.uniform(size=w2shp, low=-self.hif, high=self.hif)
+        obj.b1 = N.zeros(w1shp)
+        obj.b2 = N.zeros(w2shp[1])
+
+        QuadraticDAA._instance_initialize(self, obj, lr, seed, qfilter_relscale, **init)
+
 
 
-class SigmoidXEDenoisingAA(DenoisingAA):
-    """
-    @todo: Merge this into the above.
-    @todo: Default noise level for all daa levels
-    """
+##############################################
+#       CONVOLUTIONAL QUADRATIC DAA          #
+##############################################
+class ConvQuadraticDAA(QuadraticDAA):
+
+    def __init__(self, img_shape, n_hid_per_pixel,
+                 filter_shape, step_size=(1,1), conv_mode='valid',
+                 n_quadratic_filters=0, batch_size=4,
+                 regularize = True, hid_fn=NN.sigmoid,
+                 reconstruction_cost_function=cost.cross_entropy, **init):
+
+        QuadraticDAA.__init__(self, img_shape, n_hid_per_pixel, n_quadratic_filters,
+                batch_size, regularize, hid_fn, reconstruction_cost_function, **init)
+       
+        # need to override parameters for sparse operations (vector instead of matrix)
+        self.w1 = theano.Member(T.dmatrix())
+        self.w2 = theano.Member(T.dmatrix())
+        self.b1 = theano.Member(T.dmatrix())
+        self.qfilters = [theano.Member(T.dmatrix()) for i in xrange(n_quadratic_filters)]
+
+        self.filter_shape = filter_shape
+        self.step_size = step_size
+        self.conv_mode = conv_mode
+
+    def define_propup(self, container, input):
+
+        lin_hid_activ, self.hid_shape = sp.convolve(self.w1, self.filter_shape,
+                self.n_hid_per_pixel, self.input, self.img_shape, self.step_size, 
+                self.conv_mode, flatten=False)
+        self.nl1feats = N.prod(self.hid_shape)
+
+        # apply quadratic filters
+        qsum = 0
+        for qf in self.qfilters:
+            temp, hidshape = sp.convolve(qf, self.filter_shape, self.n_hid_per_pixel,
+                    self.input, self.img_shape, self.step_size, self.conv_mode, flatten=False)
+            qsum = qsum + temp**2
+        quad_hid_activ = qsum
+
+        hid_activ = lin_hid_activ + quad_hid_activ if self.n_quadratic_filters \
+                    else lin_hid_activ
 
-    def build_corrupted_input(self):
-        self.noise_level = theano.Member(T.scalar())
-        return self.random.binomial(T.shape(self.input), 1, 1 - self.noise_level) * self.input
+        container.hidden_activation = hid_activ
+        container.hidden = T.flatten(self.hid_fn(container.hidden_activation), 2)
+
+    def define_propdown(self, container):
+        pass
+
+
+    def _instance_initialize(self, obj, lr, seed=1, qfilter_relscale=.01, **init):
+
+        # change weight shapes based on sparse weight matrix parameters
+        DAA._instance_initialize(self, obj, lr, seed, alloc=False, **init)
+
+        # override weight initialization
+        w1shp = (self.n_hid_per_pixel, N.prod(self.filter_shape))
+        w2shp = (N.prod(self.hid_shape), self.input_size)
+        obj.w1 = self.R.uniform(size=w1shp, low=-self.inf, high=self.inf)
+        obj.w2 = self.R.uniform(size=w2shp, low=-self.hif, high=self.hif)
+        obj.b1 = N.zeros((self.n_hid_per_pixel,1))
+        obj.b2 = N.zeros(w2shp[1])
+
+        QuadraticDAA._instance_initialize(self, obj, lr, seed, qfilter_relscale, **init)
 
-    def hid_activation_function(self, activation):
-        return self.activation_function(activation)
 
-    def out_activation_function(self, activation):
-        return self.activation_function(activation)
+##############################################
+#                 TEST CODE
+##############################################
+def debug():
+    img_shape = (3,3)
+    n_hid_per_pixel = 1
+    filter_shape = (2,2)
+    step_size = (1,1)
+    conv_mode = 'full'
+    batch_size = 10
+
+    R = N.random.RandomState(100)
+    data = R.random_integers(0, 1, size=(batch_size, N.prod(img_shape)))
+
+    print 'Instantiating DAA...',
+    daa_model = DAA(img_shape, n_hid_per_pixel, batch_size=batch_size)
+    daa_model.init_behavioural()
+    daa = daa_model.make(lr=0.1)
+    daa.update(data)
+    print 'done'
 
-    def build_reconstruction_costs(self, output):
-        return self.reconstruction_cost_function(self.input, output)
+    print 'Instantiating QuadraticDAA...',
+    qdaa_model = QuadraticDAA(img_shape, n_hid_per_pixel,
+            n_quadratic_filters=1, batch_size=batch_size)
+    qdaa_model.init_behavioural()
+    qdaa = qdaa_model.make(lr=0.1)
+    qdaa.update(data)
+    print 'done'
+
+    print 'Instantiating SparseQuadraticDAA...',
+    sp_qdaa_model = SparseQuadraticDAA(img_shape, n_hid_per_pixel,
+            filter_shape, step_size, conv_mode, 
+            n_quadratic_filters=1, batch_size=batch_size)
+    sp_qdaa_model.init_behavioural()
+    sp_qdaa = sp_qdaa_model.make(lr=0.1)
+    sp_qdaa.representation(data)
+    sp_qdaa.reconstruction(data)
+    sp_qdaa.update(data)
+    print 'done!'
+
+    print 'Instantiating ConvQuadraticDAA...',
+    conv_qdaa_model = ConvQuadraticDAA(img_shape, n_hid_per_pixel,
+            filter_shape, step_size, conv_mode, 
+            n_quadratic_filters=1, batch_size=batch_size)
+    conv_qdaa_model.init_behavioural()
+    conv_qdaa = conv_qdaa_model.make(lr=0.1)
+    conv_qdaa.representation(data)
+    conv_qdaa.reconstruction(data)
+    conv_qdaa.update(data)
+    print 'done!'
+   
+def test():
+    
+    from pylearn.datasets import MNIST
+    from pylearn.datasets import make_dataset
+    import pylab as pl
+
+    def showimg(x,y):
+        for i in range(batch_size):
+            pl.subplot(2,batch_size,i+1); pl.gray(); pl.axis('off');
+            pl.imshow(x[i,:].reshape(img_shape))
+            pl.subplot(2,batch_size,batch_size+i+1); pl.gray(); pl.axis('off');
+            pl.imshow(y[i,:].reshape(img_shape))
+        pl.show()
 
-    def build_regularization(self):
-        self.l2_coef = theano.Member(T.scalar())
-        if self.tie_weights:
-            return self.l2_coef * T.sum(self.w1 * self.w1)
-        else:
-            return self.l2_coef * (T.sum(self.w1 * self.w1) + T.sum(self.w2 * self.w2))
+    img_shape = (28,28)
+    n_hid_per_pixel = 1
+    n_quadratic_filters = 0
+    batch_size = 4
+    epochs = 50
+    lr = .01
+    filter_shape = (5,5)
+    step_size = (2,2)
+    conv_mode = 'valid'
+
+    dataset = make_dataset('MNIST',variant='1k')
+
+    #print 'Instantiating DAA...',
+    #daa_model = DAA(img_shape, n_hid_per_pixel, batch_size=batch_size, regularize=False)
+    #daa_model.init_behavioural()
+    #daa = daa_model.make(lr=lr, mode='FAST_RUN')
+    #print 'done'
+
+    #print 'Instantiating QuadraticDAA...',
+    #daa_model = QuadraticDAA(img_shape, n_hid_per_pixel,
+            #n_quadratic_filters=n_quadratic_filters, batch_size=batch_size)
+    #daa_model.init_behavioural()
+    #daa = daa_model.make(lr=0.1, mode='FAST_RUN')
 
-    def _instance_initialize(self, obj, input_size = None, hidden_size = None, seed = None, **init):
-        init.setdefault('noise_level', 0)
-        init.setdefault('l2_coef', 0)
-        super(SigmoidXEDenoisingAA, self)._instance_initialize(obj, input_size, hidden_size, seed, **init)
+    print 'Instantiating SparseQuadraticDAA...',
+    daa_model = SparseQuadraticDAA(img_shape, n_hid_per_pixel,
+            filter_shape, step_size, conv_mode, 
+            n_quadratic_filters=n_quadratic_filters, batch_size=batch_size)
+    daa_model.init_behavioural()
+    daa = daa_model.make(lr=0.1, mode='FAST_RUN')
 
+    #print 'Instantiating ConvQuadraticDAA...',
+    #daa_model = ConvQuadraticDAA(img_shape, n_hid_per_pixel,
+            #filter_shape, step_size, conv_mode, 
+            #n_quadratic_filters=1, batch_size=batch_size)
+    #daa_model.init_behavioural()
+    #daa = daa_model.make(lr=0.1, mode='FAST_RUN')
+ 
+    for ep in range(epochs):
+        print '********** Epoch %i *********' % ep
+        imgi=0
+        for i in range(dataset.train.x.shape[0]/batch_size):
+            x = dataset.train.x[imgi:imgi+batch_size,:]
+            print daa.update(x)
+            imgi += batch_size
+
+        if (ep+1) % 1 == 0:
+            starti = N.floor(N.random.rand()*(1000-4))
+            x = dataset.train.x[starti:starti+batch_size,:]
+            x_rec = daa.reconstruction(x)
+            showimg(x,x_rec)
+
+if __name__ == '__main__':
+    test()

--- a/pylearn/algorithms/logistic_regression.py	Wed Jan 21 03:20:16 2009 -0500
+++ b/pylearn/algorithms/logistic_regression.py	Wed Jan 21 03:23:50 2009 -0500
@@ -27,7 +27,7 @@
             n_in=None, n_out=None,
             input=None, target=None, 
             w=None, b=None, 
-            l2=None, l1=None):
+            l2=None, l1=None, regularize=False):
         super(LogRegN, self).__init__() #boilerplate
 
         self.n_in = n_in

--- a/pylearn/algorithms/stacker.py	Wed Jan 21 03:20:16 2009 -0500
+++ b/pylearn/algorithms/stacker.py	Wed Jan 21 03:23:50 2009 -0500
@@ -98,4 +98,3 @@
         for layer in obj.layers:
             rval += layer.flops_approx()
         return rval
-

--- a/pylearn/algorithms/tests/test_daa.py	Wed Jan 21 03:20:16 2009 -0500
+++ b/pylearn/algorithms/tests/test_daa.py	Wed Jan 21 03:23:50 2009 -0500
@@ -1,6 +1,7 @@
 #!/usr/bin/python
 
 from pylearn import algorithms as models
+import pylearn.algorithms.daa as moddaa
 import theano
 import numpy
 import time
@@ -9,8 +10,9 @@
 
 def test_train_daa(mode = theano.Mode('c|py', 'fast_run')):
 
-    ndaa = 3
-    daa = models.Stacker([(models.SigmoidXEDenoisingAA, 'hidden')] * ndaa + [(models.BinRegressor, 'output')],
+    ndaa = 3  # number of stacked DAA modules
+    daa = models.Stacker([(moddaa.SigmoidXEDenoisingAA, 'hidden')] * ndaa +\
+                         [(models.BinRegressor, 'output')],
                          regularize = False)
 
     model = daa.make([4, 20, 20, 20, 1],
@@ -38,7 +40,8 @@
 def test_train_daa2(mode = theano.Mode('c|py', 'fast_run')):
 
     ndaa = 3
-    daa = models.Stacker([(models.SigmoidXEDenoisingAA, 'hidden')] * ndaa + [(pylearn.algorithms.logistic_regression.Module_Nclass, 'pred')],
+    daa = models.Stacker([(moddaa.SigmoidXEDenoisingAA, 'hidden')] * ndaa +\
+                         [(pylearn.algorithms.logistic_regression.LogRegN, 'pred')],
                          regularize = False)
 
     model = daa.make([4] + [20] * ndaa + [10],

--- a/pylearn/dbdict/api0.py	Wed Jan 21 03:20:16 2009 -0500
+++ b/pylearn/dbdict/api0.py	Wed Jan 21 03:23:50 2009 -0500
@@ -476,7 +476,7 @@
                                     h_self._link_table.name);
         
         #print 'Creating sql view with command:\n', viewsql;
-
+        print viewsql
         h_self._engine.execute(viewsql);
         s.commit();
         s.close()

--- a/pylearn/dbdict/sql_commands.py	Wed Jan 21 03:20:16 2009 -0500
+++ b/pylearn/dbdict/sql_commands.py	Wed Jan 21 03:23:50 2009 -0500
@@ -8,22 +8,28 @@
     col_queries = []
     colname0 = None
     for i, (colname, table_col) in enumerate(cols):
+        safe_col = colname.replace('__','')
+        safe_col = safe_col.replace('.','__')
+      
+        cols[i][0] = safe_col
+
         if i == 0:
-            q = """(select %(dict_id)s as v%(i)s_id, %(table_col)s as %(colname)s 
+            q = """(select %(dict_id)s as v%(i)s_id, %(table_col)s as %(safe_col)s 
                     from \"%(keytab)s\", \"%(linktab)s\"
                     where name='%(colname)s'
                     and \"%(keytab)s\".%(id_col)s = \"%(linktab)s\".%(pair_id)s)
-                    %(colname)s """ % locals()
-            colname0 = colname
+                    %(safe_col)s """ % locals()
+            colname0 = safe_col
         else:
-            q = """ LEFT OUTER JOIN (select %(dict_id)s as v%(i)s_id, %(table_col)s as %(colname)s 
+            q = """ LEFT OUTER JOIN (select %(dict_id)s as v%(i)s_id, %(table_col)s as %(safe_col)s 
                     from \"%(keytab)s\", \"%(linktab)s\" 
                     where name='%(colname)s'
                     and  \"%(keytab)s\".%(id_col)s = \"%(linktab)s\".%(pair_id)s)
-                    %(colname)s 
-                    on %(colname0)s.v0_id = %(colname)s.v%(i)s_id""" % locals()
+                    %(safe_col)s 
+                    on %(colname0)s.v0_id = %(safe_col)s.v%(i)s_id""" % locals()
+
         col_queries.append(q)
-
+       
     header = " create or replace view %s as select %s.v0_id as id, %s from " \
             % (viewname, colname0, (", ".join([c[0] for c in cols])))