pylearn: learner.py comparison

comparison learner.py @ 134:3f4e5c9bdc5e

Fixes to ApplyFunctionDataSet and other things to make learner and mlp work

author	Yoshua Bengio <bengioy@iro.umontreal.ca>
date	Fri, 09 May 2008 17:38:57 -0400
parents	b4657441dd65
children	0d8e721cc63c b7ca3545186b

comparison

equal deleted inserted replaced

-:b4657441dd65
+:3f4e5c9bdc5e
-from dataset import AttributesHolder,AbstractFunction
+from dataset import AttributesHolder,AbstractFunction,ApplyFunctionDataSet,DataSet,CachedDataSet
-import compile
+import theano
+from theano import compile
 from theano import tensor as t
 class Learner(AttributesHolder):
 """
 Base class for learning algorithms, provides an interface
 """
 Return a list with the values of the learner's attributes (or optionally, a deep copy).
 """
 return self.names2attributes(self.attributeNames(),return_copy)
-def names2attributes(self,names,return_copy=False):
+def names2attributes(self,names):
 """
 Private helper function that maps a list of attribute names to a list
 of (optionally copies) values of attributes.
 """
-if return_copy:
+res=[]
-return [copy.deepcopy(self.__getattribute__(name).data) for name in names]
+for name in names:
-else:
+assert name in names
-return [self.__getattribute__(name).data for name in names]
+res.append(self.__getattribute__(name))
+return res
-def updateInputAttributes(self):
-"""
-A subset of self.attributeNames() which are the names of attributes needed by update() in order
-to do its work.
-"""
-raise AbstractFunction()
 def useInputAttributes(self):
 """
 A subset of self.attributeNames() which are the names of attributes needed by use() in order
 to do its work.
 """
 raise AbstractFunction()
-def updateOutputAttributes(self):
-"""
-A subset of self.attributeNames() which are the names of attributes modified/created by update() in order
-to do its work.
-By default these are inferred from the various update output attributes:
-"""
-return ["parameters"] + self.updateMinibatchOutputAttributes() + self.updateEndOutputAttributes()
 def useOutputAttributes(self):
 """
 A subset of self.attributeNames() which are the names of attributes modified/created by use() in order
 to do its work.
 dependant de Theano
 """
 def __init__(self):
 Learner.__init__(self)
+self.use_functions_dictionary={}
 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.
 if stats_collector:
 stats_collector_inputs = stats_collector.input2UpdateAttributes()
 for attribute in stats_collector_inputs:
 if attribute not in input_fields:
 output_fields.append(attribute)
-key = (input_fields,output_fields)
+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))
 def f(*input_field_values):
 input_attribute_values = self.names2attributes(use_input_attributes)
-results = complete_f(*(input_field_values + input_attribute_values))
+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)]
 if use_output_attributes:
 self.setAttributes(use_output_attributes,output_attribute_values)
 return output_field_values
 """
 def __init__(self):
 TLearner.__init__(self)
-self.update_minibatch_function = compile.function
+self.update_minibatch_function = compile.function(self.names2OpResults(self.updateMinibatchOutputAttributes()+
-(self.names2OpResults(self.updateMinibatchOutputAttributes()+
+self.updateMinibatchInputFields()),
-self.updateMinibatchInputFields()),
+self.names2OpResults(self.updateMinibatchOutputAttributes()))
-self.names2OpResults(self.updateMinibatchOutputAttributes()))
+self.update_end_function = compile.function(self.names2OpResults(self.updateEndInputAttributes()),
-self.update_end_function = compile.function
+self.names2OpResults(self.updateEndOutputAttributes()))
-(self.names2OpResults(self.updateEndInputAttributes()),
-self.names2OpResults(self.updateEndOutputAttributes()))
 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
 def updateStart(self,training_set):
 pass
 def updateEnd(self):
 self.setAttributes(self.updateEndOutputAttributes(),
-self.update_end_function
+self.update_end_function(*self.names2attributes(self.updateEndInputAttributes())))
-(self.names2attributes(self.updateEndInputAttributes())))
 self.parameters = self.names2attributes(self.parameterAttributes())
 def updateMinibatch(self,minibatch):
 # make sure all required fields are allocated and initialized
 self.allocate(minibatch)
+input_attributes = self.names2attributes(self.updateMinibatchInputAttributes())
+input_fields = minibatch(*self.updateMinibatchInputFields())
 self.setAttributes(self.updateMinibatchOutputAttributes(),
 # concatenate the attribute values and field values and then apply update fn
-self.update_minibatch_function(*(self.names2attributes
+self.update_minibatch_function(*(input_attributes+input_fields)))
-(self.updateMinibatchInputAttributes()))
-+ minibatch(self.updateMinibatchInputFields())))
 def isLastEpoch(self):
 """
 This method is called at the end of each epoch (cycling over the training set).
 It returns a boolean to indicate if this is the last epoch.
 self.setAttributes(new_params_names,
 [t.add_inplace(param,self._learning_rate*t.grad(loss,param))
 for param in old_params])
 MinibatchUpdatesTLearner.__init__(self)
+def namesOfAttributesToComputeOutputs(self,output_names):
+"""
+The output_names are attribute names (not the corresponding Result names, which have leading _).
+Return the corresponding input names
+"""
+all_inputs = t.gof.graph.inputs(self.names2OpResults(output_names))
+# remove constants and leading '_' in name
+return [r.name for r in all_inputs if isinstance(r,theano.Result) and \
+not isinstance(r,theano.Constant) and not isinstance(r,theano.Value)]
+#inputs = []
+#for r in all_inputs:
+#    if isinstance(r,theano.Result) and \
+#    not isinstance(r,theano.Constant) and not isinstance(r,theano.Value):
+#       inputs.append(r.name)
+#return inputs
 def isLastEpoch(self):
 return self.truly_online
 def updateMinibatchInputAttributes(self):
 return self.parameterAttributes()
 def updateMinibatchOutputAttributes(self):
 return ["new_"+name for name in self.parameterAttributes()]
 def updateEndInputAttributes(self):
+return self.namesOfAttributesToComputeOutputs(self.updateEndOutputAttributes())
+def useInputAttributes(self):
 return self.parameterAttributes()
+def useOutputAttributes(self):
+return []

Mercurial > pylearn

comparison learner.py @ 134:3f4e5c9bdc5e