pylearn: mlp_factory_approach.py comparison

comparison mlp_factory_approach.py @ 267:4dad41215967

mergec

author	James Bergstra <bergstrj@iro.umontreal.ca>
date	Wed, 04 Jun 2008 17:49:28 -0400
parents	ae0a8345869b
children	eded3cb54930

comparison

equal deleted inserted replaced

-:6e69fb91f3c0
+:4dad41215967
-import copy, sys
+import copy, sys, os
 import numpy
 import theano
 from theano import tensor as T
-from pylearn import dataset, nnet_ops, stopper, LookupList
+from pylearn import dataset, nnet_ops, stopper, LookupList, filetensor
 class AbstractFunction (Exception): pass
 class AutoName(object):
 """
 def __copy__(self):
 raise Exception('why not called?')
 return GraphLearner.Model(self.algo, [copy.copy(p) for p in params])
+def __eq__(self,other,tolerance=0.) :
+""" Only compares weights of matrices and bias vector. """
+if not isinstance(other,GraphLearner.Model) :
+return False
+for p in range(4) :
+if self.params[p].shape != other.params[p].shape :
+return False
+if not numpy.all( numpy.abs(self.params[p] - other.params[p]) <= tolerance ) :
+return False
+return True
 def _cache(self, key, valfn):
 d = self._fn_cache
 if key not in d:
 d[key] = valfn()
 return d[key]
 def update_minibatch(self, minibatch):
-assert isinstance(minibatch, LookupList)
+#assert isinstance(minibatch, LookupList) # why false???
 self.update_fn(minibatch['input'], minibatch['target'], *self.params)
 def update(self, dataset,
 default_minibatch_size=32):
 """Update this model from more training data."""
 params = self.params
 minibatch_size = min(default_minibatch_size, len(dataset))
 for mb in dataset.minibatches(['input', 'target'], minibatch_size=minibatch_size):
 self.update_minibatch(mb)
+def save(self, f):
+self.algo.graph.save(f, self)
 def __call__(self, testset, fieldnames=['output_class']):
 """Apply this model (as a function) to new data.
 @param testset: DataSet, whose fields feed Result terms in self.algo.g
 def train_iter(self, trainset):
 raise AbstractFunction
 optimizer = Opt()
+def load(self,f) :
+raise AbstractFunction
+def save(self,f,model) :
+raise AbstractFunction
 def __init__(self, graph):
 self.graph = graph
 def _fn(self, inputs, outputs):
 # Caching here would hamper multi-threaded apps
 @return: model
 @rtype: GraphLearner.Model instance
 """
 iparams = self.graph.iparams() if iparams is None else iparams
+# if we load, type(trainset) == 'str'
+if isinstance(trainset,str) or isinstance(trainset,file):
+#loadmodel = GraphLearner.Model(self, iparams)
+loadmodel = self.graph.load(self,trainset)
+return loadmodel
 curmodel = GraphLearner.Model(self, iparams)
 best = curmodel
 if trainset is not None:
 #do some training by calling Model.update_minibatch()
 stp.next()
 if validset:
 curmodel = best
 return curmodel
 def graphMLP(ninputs, nhid, nclass, lr_val, l2coef_val=0.0):
 def wrapper(i, node, thunk):
 if 0:
 print i, node
 print thunk.inputs
 print thunk.outputs
 loss_01 = T.neq(output_class, target)
 #g_params = T.grad(nll + regularization, params)
 g_params = T.grad(nll, params)
 new_params = [T.sub_inplace(p, lr * gp) for p,gp in zip(params, g_params)]
+def __eq__(self,other) :
+print 'G.__eq__ from graphMLP(), not implemented yet'
+return NotImplemented
+def load(self, algo, f):
+""" Load from file the 2 matrices and bias vectors """
+cloase_at_end = False
+if isinstance(f,str) :
+f = open(f,'r')
+close_at_end = True
+params = []
+for i in xrange(4):
+params.append(filetensor.read(f))
+if close_at_end :
+f.close()
+return GraphLearner.Model(algo, params)
+def save(self, f, model):
+""" Save params to file, so 2 matrices and 2 bias vectors. Same order as iparams. """
+cloase_at_end = False
+if isinstance(f,str) :
+f = open(f,'w')
+close_at_end = True
+for p in model.params:
+filetensor.write(f,p)
+if close_at_end :
+f.close()
 def iparams(self):
+""" init params. """
 def randsmall(*shape):
 return (numpy.random.rand(*shape) -0.5) * 0.001
 return [randsmall(ninputs, nhid)
 , randsmall(nhid)
 , randsmall(nhid, nclass)
 n_match = sum(omatch)
 self.failUnless(n_match ==  (numpy.sum(training_set1.fields()['target'] ==
 training_set2.fields()['target'])), omatch)
+model1.save('/tmp/model1')
+#denoising_aa = GraphLearner(denoising_g)
+#model1 = denoising_aa(trainset)
+#hidset = model(trainset, fieldnames=['hidden'])
+#model2 = denoising_aa(hidset)
+#f = open('blah', 'w')
+#for m in model:
+#    m.save(f)
+#filetensor.write(f, initial_classification_weights)
+#f.flush()
+#deep_sigmoid_net = GraphLearner(deepnetwork_g)
+#deep_model = deep_sigmoid_net.load('blah')
+#deep_model.update(trainset)  #do some fine tuning
+model1_dup = learn_algo('/tmp/model1')
 def equiv(self, g0, g1):
 training_set1 = dataset.ArrayDataSet(numpy.array([[0, 0, 0],
 [0, 1, 1],
 [1, 0, 1],
 [1, 1, 1]]),

Mercurial > pylearn

comparison mlp_factory_approach.py @ 267:4dad41215967