pylearn: learner.py comparison

comparison learner.py @ 180:2698c0feeb54

mlp seems to work!

author	Yoshua Bengio <bengioy@iro.umontreal.ca>
date	Tue, 13 May 2008 15:35:43 -0400
parents	69759976b3ac
children	cb6b945acf5a

comparison

equal deleted inserted replaced

-:9911d2cc3c01
+:2698c0feeb54
 from exceptions import *
 from dataset import AttributesHolder,ApplyFunctionDataSet,DataSet,CachedDataSet
 import theano
 from theano import compile
 from theano import tensor as t
+from misc import Print
+Print = lambda x: lambda y: y
 class Learner(AttributesHolder):
 """
 Base class for learning algorithms, provides an interface
 that allows various algorithms to be applicable to generic learning
 algorithms.
 be used as fields or
 attributes in input/output datasets or in
 stats collectors.  All these attributes
 are expected to be theano.Result objects
 (with a .data property and recognized by
-theano.Function for compilation).  The sub-class
+theano.function for compilation).  The sub-class
 constructor defines the relations between the
 Theano variables that may be used by 'use'
 and 'update' or by a stats collector.
 - defaultOutputFields(input_fields): return a list of default
 dataset output fields when
 @todo pousser dans Learner toute la poutine qui peut l'etre sans etre
 dependant de Theano
 """
-def __init__(self):
+def __init__(self,linker="c|py"):
 Learner.__init__(self)
 self.use_functions_dictionary={}
+self.linker=linker
 def defaultOutputFields(self, input_fields):
 """
 Return a default list of output field names (to put in the output dataset).
 This will be used when None are provided (as output_fields) by the caller of the 'use' method.
 key = (tuple(input_fields),tuple(output_fields))
 if key not in self.use_functions_dictionary:
 use_input_attributes = self.useInputAttributes()
 use_output_attributes = self.useOutputAttributes()
 complete_f = compile.function(self.names2OpResults(input_fields+use_input_attributes),
-self.names2OpResults(output_fields+use_output_attributes))
+self.names2OpResults(output_fields+use_output_attributes),
+self.linker)
 def f(*input_field_values):
 input_attribute_values = self.names2attributes(use_input_attributes)
 results = complete_f(*(list(input_field_values) + input_attribute_values))
 output_field_values = results[0:len(output_fields)]
 output_attribute_values = results[len(output_fields):len(results)]
 (whose names are specified by the user's subclass with the
 parameterAttributes() method)
 """
-def __init__(self):
+def __init__(self,linker="c|py"):
-TLearner.__init__(self)
+TLearner.__init__(self,linker)
 self.update_minibatch_function = compile.function(self.names2OpResults(self.updateMinibatchInputAttributes()+
 self.updateMinibatchInputFields()),
-self.names2OpResults(self.updateMinibatchOutputAttributes()))
+self.names2OpResults(self.updateMinibatchOutputAttributes()),
+linker)
 self.update_end_function = compile.function(self.names2OpResults(self.updateEndInputAttributes()),
-self.names2OpResults(self.updateEndOutputAttributes()))
+self.names2OpResults(self.updateEndOutputAttributes()),
+linker)
 def allocate(self, minibatch):
 """
 This function is called at the beginning of each L{updateMinibatch}
 and should be used to check that all required attributes have been
 Sub-classes must define the following:
 - self._learning_rate (may be changed by the sub-class between epochs or minibatches)
 - self.lossAttribute()  = name of the loss field
 """
-def __init__(self,truly_online=False):
+def __init__(self,truly_online=False,linker="c|py"):
 """
 If truly_online then only one pass is made through the training set passed to update().
 SUBCLASSES SHOULD CALL THIS CONSTRUCTOR ONLY AFTER HAVING DEFINED ALL THEIR THEANO FORMULAS
 """
 # create the formulas for the gradient update
 old_params = [self.__getattribute__("_"+name) for name in self.parameterAttributes()]
 new_params_names = ["_new_"+name for name in self.parameterAttributes()]
 loss = self.__getattribute__("_"+self.lossAttribute())
 self.setAttributes(new_params_names,
-[t.add_inplace(param,self._learning_rate*t.grad(loss,param))
+[t.add_inplace(param,-self._learning_rate*Print("grad("+param.name+")")(t.grad(loss,param)))
 for param in old_params])
-MinibatchUpdatesTLearner.__init__(self)
+MinibatchUpdatesTLearner.__init__(self,linker)
 def namesOfAttributesToComputeOutputs(self,output_names):
 """
 The output_names are attribute names (not the corresponding Result names, which have leading _).
 def isLastEpoch(self):
 return self.truly_online
 def updateMinibatchInputAttributes(self):
-return self.parameterAttributes()
+return self.parameterAttributes()+["learning_rate"]
 def updateMinibatchOutputAttributes(self):
 return ["new_"+name for name in self.parameterAttributes()]
 def updateEndInputAttributes(self):

Mercurial > pylearn

comparison learner.py @ 180:2698c0feeb54