Mercurial > pylearn
changeset 634:9b24b4345f52
merge
| author | desjagui@atchoum.iro.umontreal.ca |
|---|---|
| date | Wed, 21 Jan 2009 03:27:13 -0500 |
| parents | e242c12eb30d (diff) e52a5c3aaca5 (current diff) |
| children | 89bc88affef0 |
| files | |
| diffstat | 7 files changed, 436 insertions(+), 144 deletions(-) [+] |
line wrap: on
line diff
--- a/pylearn/algorithms/cost.py Tue Jan 20 23:32:24 2009 -0500 +++ b/pylearn/algorithms/cost.py Wed Jan 21 03:27:13 2009 -0500 @@ -14,12 +14,13 @@ def quadratic(target, output, axis=1): return T.mean(T.sqr(target - output), axis=axis) -def cross_entropy(target, output, axis=1): +def cross_entropy(target, output, mean_axis=0, sum_axis=1): """ @todo: This is essentially duplicated as nnet_ops.binary_crossentropy @warning: OUTPUT and TARGET are reversed in nnet_ops.binary_crossentropy """ - return -T.mean(target * T.log(output) + (1 - target) * T.log(1 - output), axis=axis) + XE = target * T.log(output) + (1 - target) * T.log(1 - output) + return -T.mean(T.sum(XE, axis=sum_axis),axis=mean_axis) def KL_divergence(target, output): """
--- a/pylearn/algorithms/daa.py Tue Jan 20 23:32:24 2009 -0500 +++ b/pylearn/algorithms/daa.py Wed Jan 21 03:27:13 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 Tue Jan 20 23:32:24 2009 -0500 +++ b/pylearn/algorithms/logistic_regression.py Wed Jan 21 03:27:13 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 Tue Jan 20 23:32:24 2009 -0500 +++ b/pylearn/algorithms/stacker.py Wed Jan 21 03:27:13 2009 -0500 @@ -98,4 +98,3 @@ for layer in obj.layers: rval += layer.flops_approx() return rval -
--- a/pylearn/algorithms/tests/test_daa.py Tue Jan 20 23:32:24 2009 -0500 +++ b/pylearn/algorithms/tests/test_daa.py Wed Jan 21 03:27:13 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 Tue Jan 20 23:32:24 2009 -0500 +++ b/pylearn/dbdict/api0.py Wed Jan 21 03:27:13 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 Tue Jan 20 23:32:24 2009 -0500 +++ b/pylearn/dbdict/sql_commands.py Wed Jan 21 03:27:13 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])))